cmd/compile: better job of naming compound types
Compound AUTO types weren't named previously. That was because live
variable analysis (plive.go) doesn't handle spilling to compound types.
It can't handle them because there is no valid place to put VARDEFs when
regalloc is spilling compound types.
compound types = multiword builtin types: complex, string, slice, and
interface.
Instead, we split named AUTOs into individual one-word variables. For
example, a string s gets split into a byte ptr s.ptr and an integer
s.len. Those two variables can be spilled to / restored from
independently. As a result, live variable analysis can handle them
because they are one-word objects.
This CL will change how AUTOs are described in DWARF information.
Consider the code:
func f(s string, i int) int {
x := s[i:i+5]
g()
return lookup(x)
}
The old compiler would spill x to two consecutive slots on the stack,
both named x (at offsets 0 and 8). The new compiler spills the pointer
of x to a slot named x.ptr. It doesn't spill x.len at all, as it is a
constant (5) and can be rematerialized for the call to lookup.
So compound objects may not be spilled in their entirety, and even if
they are they won't necessarily be contiguous. Such is the price of
optimization.
Re-enable live variable analysis tests. One test remains disabled, it
fails because of #14904.
Change-Id: I8ef2b5ab91e43a0d2136bfc231c05d100ec0b801
Reviewed-on: https://go-review.googlesource.com/21233
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 99ff002..5626feb 100644
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -3762,12 +3762,6 @@
// Don't track autotmp_ variables.
return
}
- if n.Class == PAUTO && (v.Type.IsString() || v.Type.IsSlice() || v.Type.IsInterface()) {
- // TODO: can't handle auto compound objects with pointers yet.
- // The live variable analysis barfs because we don't put VARDEF
- // pseudos in the right place when we spill to these nodes.
- return
- }
if n.Class == PPARAMOUT {
// Don't track named output values. This prevents return values
// from being assigned too early. See #14591 and #14762. TODO: allow this.
@@ -4175,6 +4169,96 @@
return n
}
+func (e *ssaExport) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
+ n := name.N.(*Node)
+ ptrType := Ptrto(Types[TUINT8])
+ lenType := Types[TINT]
+ if n.Class == PAUTO && !n.Addrtaken {
+ // Split this string up into two separate variables.
+ p := e.namedAuto(n.Sym.Name+".ptr", ptrType)
+ l := e.namedAuto(n.Sym.Name+".len", lenType)
+ return ssa.LocalSlot{p, ptrType, 0}, ssa.LocalSlot{l, lenType, 0}
+ }
+ // Return the two parts of the larger variable.
+ return ssa.LocalSlot{n, ptrType, name.Off}, ssa.LocalSlot{n, lenType, name.Off + int64(Widthptr)}
+}
+
+func (e *ssaExport) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
+ n := name.N.(*Node)
+ t := Ptrto(Types[TUINT8])
+ if n.Class == PAUTO && !n.Addrtaken {
+ // Split this interface up into two separate variables.
+ f := ".itab"
+ if isnilinter(n.Type) {
+ f = ".type"
+ }
+ c := e.namedAuto(n.Sym.Name+f, t)
+ d := e.namedAuto(n.Sym.Name+".data", t)
+ return ssa.LocalSlot{c, t, 0}, ssa.LocalSlot{d, t, 0}
+ }
+ // Return the two parts of the larger variable.
+ return ssa.LocalSlot{n, t, name.Off}, ssa.LocalSlot{n, t, name.Off + int64(Widthptr)}
+}
+
+func (e *ssaExport) SplitSlice(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot, ssa.LocalSlot) {
+ n := name.N.(*Node)
+ ptrType := Ptrto(n.Type.Type)
+ lenType := Types[TINT]
+ if n.Class == PAUTO && !n.Addrtaken {
+ // Split this slice up into three separate variables.
+ p := e.namedAuto(n.Sym.Name+".ptr", ptrType)
+ l := e.namedAuto(n.Sym.Name+".len", lenType)
+ c := e.namedAuto(n.Sym.Name+".cap", lenType)
+ return ssa.LocalSlot{p, ptrType, 0}, ssa.LocalSlot{l, lenType, 0}, ssa.LocalSlot{c, lenType, 0}
+ }
+ // Return the three parts of the larger variable.
+ return ssa.LocalSlot{n, ptrType, name.Off},
+ ssa.LocalSlot{n, lenType, name.Off + int64(Widthptr)},
+ ssa.LocalSlot{n, lenType, name.Off + int64(2*Widthptr)}
+}
+
+func (e *ssaExport) SplitComplex(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
+ n := name.N.(*Node)
+ s := name.Type.Size() / 2
+ var t *Type
+ if s == 8 {
+ t = Types[TFLOAT64]
+ } else {
+ t = Types[TFLOAT32]
+ }
+ if n.Class == PAUTO && !n.Addrtaken {
+ // Split this complex up into two separate variables.
+ c := e.namedAuto(n.Sym.Name+".real", t)
+ d := e.namedAuto(n.Sym.Name+".imag", t)
+ return ssa.LocalSlot{c, t, 0}, ssa.LocalSlot{d, t, 0}
+ }
+ // Return the two parts of the larger variable.
+ return ssa.LocalSlot{n, t, name.Off}, ssa.LocalSlot{n, t, name.Off + s}
+}
+
+// namedAuto returns a new AUTO variable with the given name and type.
+func (e *ssaExport) namedAuto(name string, typ ssa.Type) ssa.GCNode {
+ t := typ.(*Type)
+ s := Lookup(name)
+ n := Nod(ONAME, nil, nil)
+ s.Def = n
+ s.Def.Used = true
+ n.Sym = s
+ n.Type = t
+ n.Class = PAUTO
+ n.Addable = true
+ n.Ullman = 1
+ n.Esc = EscNever
+ n.Xoffset = 0
+ n.Name.Curfn = Curfn
+ Curfn.Func.Dcl = append(Curfn.Func.Dcl, n)
+
+ dowidth(t)
+ e.mustImplement = true
+
+ return n
+}
+
func (e *ssaExport) CanSSA(t ssa.Type) bool {
return canSSAType(t.(*Type))
}
