| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // values are specified using the following format: |
| // (op <type> [auxint] {aux} arg0 arg1 ...) |
| // the type and aux fields are optional |
| // on the matching side |
| // - the type, aux, and auxint fields must match if they are specified. |
| // on the generated side |
| // - the type of the top-level expression is the same as the one on the left-hand side. |
| // - the type of any subexpressions must be specified explicitly. |
| // - auxint will be 0 if not specified. |
| // - aux will be nil if not specified. |
| |
| // blocks are specified using the following format: |
| // (kind controlvalue succ0 succ1 ...) |
| // controlvalue must be "nil" or a value expression |
| // succ* fields must be variables |
| // For now, the generated successors must be a permutation of the matched successors. |
| |
| // constant folding |
| (Add <t> (Const [c]) (Const [d])) && is64BitInt(t) -> (Const [c+d]) |
| (Mul <t> (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.Type> ptr (Const <config.Uintptr> [config.ptrSize])) mem) |
| (SliceCap (Load ptr mem)) -> (Load (Add <ptr.Type> ptr (Const <config.Uintptr> [config.ptrSize*2])) mem) |
| |
| // indexing operations |
| // Note: bounds check has already been done |
| (ArrayIndex (Load ptr mem) idx) -> (Load (PtrIndex <ptr.Type.Elem().Elem().PtrTo()> ptr idx) mem) |
| (PtrIndex <t> ptr idx) -> (Add ptr (Mul <config.Uintptr> idx (Const <config.Uintptr> [t.Elem().Size()]))) |
| |
| // big-object moves |
| // TODO: fix size |
| (Store dst (Load <t> src mem) mem) && t.Size() > 8 -> (Move [t.Size()] dst src mem) |
| |
| // string ops |
| (Const <t> {s}) && t.IsString() -> (StringMake (OffPtr <TypeBytePtr> [2*config.ptrSize] (Global <TypeBytePtr> {config.fe.StringSym(s.(string))})) (Const <config.Uintptr> [int64(len(s.(string)))])) // TODO: ptr |
| (Load <t> ptr mem) && t.IsString() -> (StringMake (Load <TypeBytePtr> ptr mem) (Load <config.Uintptr> (OffPtr <TypeBytePtr> [config.ptrSize] ptr) mem)) |
| (StringPtr (StringMake ptr _)) -> ptr |
| (StringLen (StringMake _ len)) -> len |
| (Store dst str mem) && str.Type.IsString() -> (Store (OffPtr <TypeBytePtr> [config.ptrSize] dst) (StringLen <config.Uintptr> str) (Store <TypeMem> dst (StringPtr <TypeBytePtr> str) mem)) |
| |
| (If (Const {c}) yes no) && c.(bool) -> (Plain nil yes) |
| (If (Const {c}) yes no) && !c.(bool) -> (Plain nil no) |
