Store floats in AuxInt to reduce allocations.
Change-Id: I101e6322530b4a0b2ea3591593ad022c992e8df8
Reviewed-on: https://go-review.googlesource.com/14320
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
"bytes"
"fmt"
"html"
+ "math"
"os"
"strings"
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:
- 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
--------
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 {
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
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)
}
}
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.
}
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...) }
(Neg32 x) -> (NEGL x)
(Neg16 x) -> (NEGW x)
(Neg8 x) -> (NEGB x)
-(Neg32F x) -> (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> {math.Copysign(0, -1)}))
-(Neg64F x) -> (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> {math.Copysign(0, -1)}))
+(Neg32F x) -> (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))]))
+(Neg64F x) -> (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))]))
(Com64 x) -> (NOTQ x)
(Com32 x) -> (NOTL x)
(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])
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
}
return 0
}
+
+// f2i is used in the rules for storing a float in AuxInt.
+func f2i(f float64) int64 {
+ return int64(math.Float64bits(f))
+}
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])
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])
case OpNeg32F:
// match: (Neg32F x)
// cond:
- // result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> {math.Copysign(0, -1)}))
+ // result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))]))
{
x := v.Args[0]
v.Op = OpAMD64PXOR
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)
case OpNeg64F:
// match: (Neg64F x)
// cond:
- // result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> {math.Copysign(0, -1)}))
+ // result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))]))
{
x := v.Args[0]
v.Op = OpAMD64PXOR
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)
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
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 {