This reverts CL 553055.
Reason for revert: causes crypto/ecdsa failures on linux ppc64/s390x builders
Change-Id: I9266b030693a5b6b1e667a009de89d613755b048
Reviewed-on: https://go-review.googlesource.com/c/go/+/575236
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
Auto-Submit: Than McIntosh <thanm@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
LoopVarHash string `help:"for debugging changes in loop behavior. Overrides experiment and loopvar flag."`
LocationLists int `help:"print information about DWARF location list creation"`
MaxShapeLen int `help:"hash shape names longer than this threshold (default 500)" concurrent:"ok"`
- MergeLocals int `help:"merge together non-interfering local stack slots" concurrent:"ok"`
- MergeLocalsDumpFunc string `help:"dump specified func in merge locals"`
- MergeLocalsHash string `help:"hash value for debugging stack slot merging of local variables" concurrent:"ok"`
- MergeLocalsTrace int `help:"trace debug output for locals merging"`
Nil int `help:"print information about nil checks"`
NoOpenDefer int `help:"disable open-coded defers" concurrent:"ok"`
NoRefName int `help:"do not include referenced symbol names in object file" concurrent:"ok"`
Debug.SyncFrames = -1 // disable sync markers by default
Debug.ZeroCopy = 1
Debug.RangeFuncCheck = 1
- Debug.MergeLocals = 1
Debug.Checkptr = -1 // so we can tell whether it is set explicitly
if Debug.PGOHash != "" {
PGOHash = NewHashDebug("pgohash", Debug.PGOHash, nil)
}
- if Debug.MergeLocalsHash != "" {
- MergeLocalsHash = NewHashDebug("mergelocals", Debug.MergeLocalsHash, nil)
- }
if Flag.MSan && !platform.MSanSupported(buildcfg.GOOS, buildcfg.GOARCH) {
log.Fatalf("%s/%s does not support -msan", buildcfg.GOOS, buildcfg.GOARCH)
// The default compiler-debugging HashDebug, for "-d=gossahash=..."
var hashDebug *HashDebug
-var FmaHash *HashDebug // for debugging fused-multiply-add floating point changes
-var LoopVarHash *HashDebug // for debugging shared/private loop variable changes
-var PGOHash *HashDebug // for debugging PGO optimization decisions
-var MergeLocalsHash *HashDebug // for debugging local stack slot merging changes
+var FmaHash *HashDebug // for debugging fused-multiply-add floating point changes
+var LoopVarHash *HashDebug // for debugging shared/private loop variable changes
+var PGOHash *HashDebug // for debugging PGO optimization decisions
// DebugHashMatchPkgFunc reports whether debug variable Gossahash
//
nameLibfuzzer8BitCounter // if PEXTERN should be assigned to __sancov_cntrs section
nameCoverageAuxVar // instrumentation counter var or pkg ID for cmd/cover
nameAlias // is type name an alias
- nameNonMergeable // not a candidate for stack slot merging
)
func (n *Name) Readonly() bool { return n.flags&nameReadonly != 0 }
func (n *Name) OpenDeferSlot() bool { return n.flags&nameOpenDeferSlot != 0 }
func (n *Name) Libfuzzer8BitCounter() bool { return n.flags&nameLibfuzzer8BitCounter != 0 }
func (n *Name) CoverageAuxVar() bool { return n.flags&nameCoverageAuxVar != 0 }
-func (n *Name) NonMergeable() bool { return n.flags&nameNonMergeable != 0 }
func (n *Name) setReadonly(b bool) { n.flags.set(nameReadonly, b) }
func (n *Name) SetNeedzero(b bool) { n.flags.set(nameNeedzero, b) }
func (n *Name) SetOpenDeferSlot(b bool) { n.flags.set(nameOpenDeferSlot, b) }
func (n *Name) SetLibfuzzer8BitCounter(b bool) { n.flags.set(nameLibfuzzer8BitCounter, b) }
func (n *Name) SetCoverageAuxVar(b bool) { n.flags.set(nameCoverageAuxVar, b) }
-func (n *Name) SetNonMergeable(b bool) { n.flags.set(nameNonMergeable, b) }
// OnStack reports whether variable n may reside on the stack.
func (n *Name) OnStack() bool {
+++ /dev/null
-// Copyright 2024 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 liveness
-
-import (
- "cmd/compile/internal/base"
- "cmd/compile/internal/bitvec"
- "cmd/compile/internal/ir"
- "cmd/compile/internal/reflectdata"
- "cmd/compile/internal/ssa"
- "cmd/internal/obj"
- "cmd/internal/src"
- "fmt"
- "os"
- "path/filepath"
- "sort"
- "strings"
-)
-
-// MergeLocalsState encapsulates information about which AUTO
-// (stack-allocated) variables within a function can be safely
-// merged/overlapped, e.g. share a stack slot with some other auto).
-// An instance of MergeLocalsState is produced by MergeLocals() below
-// and then consumed in ssagen.AllocFrame. The map 'partition' contains
-// entries of the form <N,SL> where N is an *ir.Name and SL is a slice
-// holding the indices (within 'vars') of other variables that share the
-// same slot. For example, if a function contains five variables where
-// v1/v2/v3 are safe to overlap and v4/v5 are safe to overlap, the
-// MergeLocalsState content might look like
-//
-// vars: [v1, v2, v3, v4, v5]
-// partition: v1 -> [1, 0, 2], v2 -> [1, 0, 2], v3 -> [1, 0, 2]
-// v4 -> [3, 4], v5 -> [3, 4]
-//
-// A nil MergeLocalsState indicates that no local variables meet the
-// necessary criteria for overlap.
-type MergeLocalsState struct {
- // contains auto vars that participate in overlapping
- vars []*ir.Name
- // maps auto variable to overlap partition
- partition map[*ir.Name][]int
-}
-
-// candRegion is a sub-range (start, end) corresponding to an interval
-// [st,en] within the list of candidate variables.
-type candRegion struct {
- st, en int
-}
-
-// MergeLocals analyzes the specified ssa function f to determine which
-// of its auto variables can safely share the same stack slot, returning
-// a state object that describes how the overlap should be done.
-func MergeLocals(fn *ir.Func, f *ssa.Func) *MergeLocalsState {
- cands, idx, regions := collectMergeCandidates(fn)
- if len(regions) == 0 {
- return nil
- }
- lv := newliveness(fn, f, cands, idx, 0)
-
- // If we have a local variable such as "r2" below that's written
- // but then not read, something like:
- //
- // vardef r1
- // r1.x = ...
- // vardef r2
- // r2.x = 0
- // r2.y = ...
- // <call foo>
- // // no subsequent use of r2
- // ... = r1.x
- //
- // then for the purpose of calculating stack maps at the call, we
- // can ignore "r2" completely during liveness analysis for stack
- // maps, however for stack slock merging we most definitely want
- // to treat the writes as "uses".
- lv.conservativeWrites = true
-
- lv.prologue()
- lv.solve()
- cs := &cstate{
- fn: fn,
- ibuilders: make([]IntervalsBuilder, len(cands)),
- }
- computeIntervals(lv, cs)
- rv := performMerging(lv, cs, regions)
- if err := rv.check(); err != nil {
- base.FatalfAt(fn.Pos(), "invalid mergelocals state: %v", err)
- }
- return rv
-}
-
-// Subsumed returns whether variable n is subsumed, e.g. appears
-// in an overlap position but is not the leader in that partition.
-func (mls *MergeLocalsState) Subsumed(n *ir.Name) bool {
- if sl, ok := mls.partition[n]; ok && mls.vars[sl[0]] != n {
- return true
- }
- return false
-}
-
-// IsLeader returns whether a variable n is the leader (first element)
-// in a sharing partition.
-func (mls *MergeLocalsState) IsLeader(n *ir.Name) bool {
- if sl, ok := mls.partition[n]; ok && mls.vars[sl[0]] == n {
- return true
- }
- return false
-}
-
-// Leader returns the leader variable for subsumed var n.
-func (mls *MergeLocalsState) Leader(n *ir.Name) *ir.Name {
- if sl, ok := mls.partition[n]; ok {
- if mls.vars[sl[0]] == n {
- panic("variable is not subsumed")
- }
- return mls.vars[sl[0]]
- }
- panic("not a merge candidate")
-}
-
-// Followers writes a list of the followers for leader n into the slice tmp.
-func (mls *MergeLocalsState) Followers(n *ir.Name, tmp []*ir.Name) []*ir.Name {
- tmp = tmp[:0]
- sl, ok := mls.partition[n]
- if !ok {
- panic("no entry for leader")
- }
- if mls.vars[sl[0]] != n {
- panic("followers invoked on subsumed var")
- }
- for _, k := range sl[1:] {
- tmp = append(tmp, mls.vars[k])
- }
- sort.SliceStable(tmp, func(i, j int) bool {
- return tmp[i].Sym().Name < tmp[j].Sym().Name
- })
- return tmp
-}
-
-// EstSavings returns the estimated reduction in stack size for
-// the given merge locals state.
-func (mls *MergeLocalsState) EstSavings() int {
- tot := 0
- for n := range mls.partition {
- if mls.Subsumed(n) {
- tot += int(n.Type().Size())
- }
- }
- return tot
-}
-
-// check tests for various inconsistencies and problems in mls,
-// returning an error if any problems are found.
-func (mls *MergeLocalsState) check() error {
- if mls == nil {
- return nil
- }
- used := make(map[int]bool)
- seenv := make(map[*ir.Name]int)
- for ii, v := range mls.vars {
- if prev, ok := seenv[v]; ok {
- return fmt.Errorf("duplicate var %q in vslots: %d and %d\n",
- v.Sym().Name, ii, prev)
- }
- seenv[v] = ii
- }
- for k, sl := range mls.partition {
- // length of slice value needs to be more than 1
- if len(sl) < 2 {
- return fmt.Errorf("k=%q v=%+v slice len %d invalid",
- k.Sym().Name, sl, len(sl))
- }
- // values in the slice need to be var indices
- for i, v := range sl {
- if v < 0 || v > len(mls.vars)-1 {
- return fmt.Errorf("k=%q v=+%v slpos %d vslot %d out of range of m.v", k.Sym().Name, sl, i, v)
- }
- }
- }
- for k, sl := range mls.partition {
- foundk := false
- for i, v := range sl {
- vv := mls.vars[v]
- if i == 0 {
- if !mls.IsLeader(vv) {
- return fmt.Errorf("k=%s v=+%v slpos 0 vslot %d IsLeader(%q) is false should be true", k.Sym().Name, sl, v, vv.Sym().Name)
- }
- } else {
- if !mls.Subsumed(vv) {
- return fmt.Errorf("k=%s v=+%v slpos %d vslot %d Subsumed(%q) is false should be true", k.Sym().Name, sl, i, v, vv.Sym().Name)
- }
- if mls.Leader(vv) != mls.vars[sl[0]] {
- return fmt.Errorf("k=%s v=+%v slpos %d vslot %d Leader(%q) got %v want %v", k.Sym().Name, sl, i, v, vv.Sym().Name, mls.Leader(vv), mls.vars[sl[0]])
- }
- }
- if vv == k {
- foundk = true
- if used[v] {
- return fmt.Errorf("k=%s v=+%v val slice used violation at slpos %d vslot %d", k.Sym().Name, sl, i, v)
- }
- used[v] = true
- }
- }
- if !foundk {
- return fmt.Errorf("k=%s v=+%v slice value missing k", k.Sym().Name, sl)
- }
- }
- for i := range used {
- if !used[i] {
- return fmt.Errorf("pos %d var %q unused", i, mls.vars[i])
- }
- }
- return nil
-}
-
-func (mls *MergeLocalsState) String() string {
- var leaders []*ir.Name
- for n, sl := range mls.partition {
- if n == mls.vars[sl[0]] {
- leaders = append(leaders, n)
- }
- }
- sort.Slice(leaders, func(i, j int) bool {
- return leaders[i].Sym().Name < leaders[j].Sym().Name
- })
- var sb strings.Builder
- for _, n := range leaders {
- sb.WriteString(n.Sym().Name + ":")
- sl := mls.partition[n]
- for _, k := range sl[1:] {
- n := mls.vars[k]
- sb.WriteString(" " + n.Sym().Name)
- }
- sb.WriteString("\n")
- }
- return sb.String()
-}
-
-// collectMergeCandidates visits all of the AUTO vars declared in
-// function fn and returns a list of candidate variables for merging /
-// overlapping. Return values are: 1) a slice of ir.Name's
-// corresponding to the candidates, 2) a map that maps ir.Name to slot
-// in the slice, and 3) a slice containing regions (start/end pairs)
-// corresponding to variables that could be overlapped provided that
-// their lifetimes are disjoint.
-func collectMergeCandidates(fn *ir.Func) ([]*ir.Name, map[*ir.Name]int32, []candRegion) {
- m := make(map[*ir.Name]int32)
- var cands []*ir.Name
- var regions []candRegion
-
- // Collect up the available set of appropriate AUTOs in the
- // function as a first step.
- for _, n := range fn.Dcl {
- if !n.Used() {
- continue
- }
- if !ssa.IsMergeCandidate(n) {
- continue
- }
- cands = append(cands, n)
- }
- if len(cands) < 2 {
- return nil, nil, nil
- }
-
- // Sort by pointerness, size, and then name.
- sort.SliceStable(cands, func(i, j int) bool {
- ci, cj := cands[i], cands[j]
- ihp, jhp := 0, 0
- var ilsym, jlsym *obj.LSym
- if ci.Type().HasPointers() {
- ihp = 1
- ilsym, _, _ = reflectdata.GCSym(ci.Type())
- }
- if cj.Type().HasPointers() {
- jhp = 1
- jlsym, _, _ = reflectdata.GCSym(cj.Type())
- }
- if ihp != jhp {
- return ihp < jhp
- }
- if ci.Type().Size() != cj.Type().Size() {
- return ci.Type().Size() < cj.Type().Size()
- }
- if ihp != 0 && jhp != 0 && ilsym != jlsym {
- // FIXME: find less clunky way to do this
- return fmt.Sprintf("%v", ilsym) < fmt.Sprintf("%v", jlsym)
- }
- if ci.Sym().Name != cj.Sym().Name {
- return ci.Sym().Name < cj.Sym().Name
- }
- return fmt.Sprintf("%v", ci.Pos()) < fmt.Sprintf("%v", ci.Pos())
- })
-
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= raw cand list for func %v:\n", fn)
- for i := range cands {
- dumpCand(cands[i], i)
- }
- }
-
- // Now generate a pruned candidate list-- we only want to return a
- // non-empty list if there is some possibility of overlapping two
- // vars.
- var pruned []*ir.Name
- st := 0
- for {
- en := nextRegion(cands, st)
- if en == -1 {
- break
- }
- if st == en {
- // region has just one element, we can skip it
- st++
- continue
- }
- pst := len(pruned)
- pen := pst + (en - st)
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= add part %d -> %d\n", pst, pen)
- }
-
- // non-empty region, add to pruned
- pruned = append(pruned, cands[st:en+1]...)
- regions = append(regions, candRegion{st: pst, en: pen})
- st = en + 1
- }
- if len(pruned) < 2 {
- return nil, nil, nil
- }
- for i, n := range pruned {
- m[n] = int32(i)
- }
-
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= pruned candidate list for func %v:\n", fn)
- for i := range pruned {
- dumpCand(pruned[i], i)
- }
- }
- return pruned, m, regions
-}
-
-// nextRegion starts at location idx and walks forward in the cands
-// slice looking for variables that are "compatible" (overlappable)
-// with the variable at position idx; it returns the end of the new
-// region (range of compatible variables starting at idx).
-func nextRegion(cands []*ir.Name, idx int) int {
- n := len(cands)
- if idx >= n {
- return -1
- }
- c0 := cands[idx]
- hp0 := c0.Type().HasPointers()
- for j := idx + 1; j < n; j++ {
- cj := cands[j]
- hpj := cj.Type().HasPointers()
- ok := true
- if hp0 {
- if !hpj || c0.Type().Size() != cj.Type().Size() {
- return j - 1
- }
- // GC shape must match if both types have pointers.
- gcsym0, _, _ := reflectdata.GCSym(c0.Type())
- gcsymj, _, _ := reflectdata.GCSym(cj.Type())
- if gcsym0 != gcsymj {
- return j - 1
- }
- } else {
- // If no pointers, match size only.
- if !ok || hp0 != hpj || c0.Type().Size() != cj.Type().Size() {
- return j - 1
- }
- }
- }
- return n - 1
-}
-
-type cstate struct {
- fn *ir.Func
- ibuilders []IntervalsBuilder
-}
-
-// mergeVisitRegion tries to perform overlapping of variables with a
-// given subrange of cands described by st and en (indices into our
-// candidate var list), where the variables within this range have
-// already been determined to be compatible with respect to type,
-// size, etc. Overlapping is done in a a greedy fashion: we select the
-// first element in the st->en range, then walk the rest of the
-// elements adding in vars whose lifetimes don't overlap with the
-// first element, then repeat the process until we run out of work to do.
-func (mls *MergeLocalsState) mergeVisitRegion(lv *liveness, ivs []Intervals, st, en int) {
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= mergeVisitRegion(st=%d, en=%d)\n", st, en)
- }
- n := en - st + 1
- used := bitvec.New(int32(n))
-
- nxt := func(slot int) int {
- for c := slot - st; c < n; c++ {
- if used.Get(int32(c)) {
- continue
- }
- return c + st
- }
- return -1
- }
-
- navail := n
- cands := lv.vars
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, " =-= navail = %d\n", navail)
- }
- for navail >= 2 {
- leader := nxt(st)
- used.Set(int32(leader - st))
- navail--
-
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, " =-= begin leader %d used=%s\n", leader,
- used.String())
- }
- elems := []int{leader}
- lints := ivs[leader]
-
- for succ := nxt(leader + 1); succ != -1; succ = nxt(succ + 1) {
-
- // Skip if de-selected by merge locals hash.
- if base.Debug.MergeLocalsHash != "" {
- if !base.MergeLocalsHash.MatchPosWithInfo(cands[succ].Pos(), "mergelocals", nil) {
- continue
- }
- }
- // Skip if already used.
- if used.Get(int32(succ - st)) {
- continue
- }
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, " =-= overlap of %d[%v] {%s} with %d[%v] {%s} is: %v\n", leader, cands[leader], lints.String(), succ, cands[succ], ivs[succ].String(), lints.Overlaps(ivs[succ]))
- }
-
- // Can we overlap leader with this var?
- if lints.Overlaps(ivs[succ]) {
- continue
- } else {
- // Add to overlap set.
- elems = append(elems, succ)
- lints = lints.Merge(ivs[succ])
- }
- }
- if len(elems) > 1 {
- // We found some things to overlap with leader. Add the
- // candidate elements to "vars" and update "partition".
- off := len(mls.vars)
- sl := make([]int, len(elems))
- for i, candslot := range elems {
- sl[i] = off + i
- mls.vars = append(mls.vars, cands[candslot])
- mls.partition[cands[candslot]] = sl
- }
- navail -= (len(elems) - 1)
- for i := range elems {
- used.Set(int32(elems[i] - st))
- }
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= overlapping %+v:\n", sl)
- for i := range sl {
- dumpCand(mls.vars[sl[i]], sl[i])
- }
- for i, v := range elems {
- fmt.Fprintf(os.Stderr, "=-= %d: sl=%d %s\n", i, v, ivs[v])
- }
- }
- }
- }
-}
-
-// performMerging carries out variable merging within each of the
-// candidate ranges in regions, returning a state object
-// that describes the variable overlaps.
-func performMerging(lv *liveness, cs *cstate, regions []candRegion) *MergeLocalsState {
- cands := lv.vars
- mls := &MergeLocalsState{
- partition: make(map[*ir.Name][]int),
- }
-
- // Finish intervals construction.
- ivs := make([]Intervals, len(cands))
- for i := range cands {
- var err error
- ivs[i], err = cs.ibuilders[i].Finish()
- if err != nil {
- ninstr := 0
- if base.Debug.MergeLocalsTrace != 0 {
- iidx := 0
- for k := 0; k < len(lv.f.Blocks); k++ {
- b := lv.f.Blocks[k]
- fmt.Fprintf(os.Stderr, "\n")
- for _, v := range b.Values {
- fmt.Fprintf(os.Stderr, " b%d %d: %s\n", k, iidx, v.LongString())
- iidx++
- ninstr++
- }
- }
- }
- base.FatalfAt(cands[i].Pos(), "interval construct error for var %q in func %q (%d instrs): %v", cands[i].Sym().Name, ir.FuncName(cs.fn), ninstr, err)
- return nil
- }
- }
-
- // Dump state before attempting overlap.
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= cands live before overlap:\n")
- for i := range cands {
- c := cands[i]
- fmt.Fprintf(os.Stderr, "%d: %v sz=%d ivs=%s\n",
- i, c.Sym().Name, c.Type().Size(), ivs[i].String())
- }
- fmt.Fprintf(os.Stderr, "=-= regions (%d): ", len(regions))
- for _, cr := range regions {
- fmt.Fprintf(os.Stderr, " [%d,%d]", cr.st, cr.en)
- }
- fmt.Fprintf(os.Stderr, "\n")
- }
-
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= len(regions) = %d\n", len(regions))
- }
-
- // Apply a greedy merge/overlap strategy within each region
- // of compatible variables.
- for _, cr := range regions {
- mls.mergeVisitRegion(lv, ivs, cr.st, cr.en)
- }
- if len(mls.vars) == 0 {
- return nil
- }
- return mls
-}
-
-// computeIntervals performs a backwards sweep over the instructions
-// of the function we're compiling, building up an Intervals object
-// for each candidate variable by looking for upwards exposed uses
-// and kills.
-func computeIntervals(lv *liveness, cs *cstate) {
- nvars := int32(len(lv.vars))
- liveout := bitvec.New(nvars)
-
- if base.Debug.MergeLocalsDumpFunc != "" &&
- strings.HasSuffix(fmt.Sprintf("%v", cs.fn), base.Debug.MergeLocalsDumpFunc) {
- fmt.Fprintf(os.Stderr, "=-= mergelocalsdumpfunc %v:\n", cs.fn)
- ii := 0
- for k, b := range lv.f.Blocks {
- fmt.Fprintf(os.Stderr, "b%d:\n", k)
- for _, v := range b.Values {
- pos := base.Ctxt.PosTable.Pos(v.Pos)
- fmt.Fprintf(os.Stderr, "=-= %d L%d|C%d %s\n", ii, pos.RelLine(), pos.RelCol(), v.LongString())
- ii++
- }
- }
- }
-
- // Count instructions.
- ninstr := 0
- for _, b := range lv.f.Blocks {
- ninstr += len(b.Values)
- }
- // current instruction index during backwards walk
- iidx := ninstr - 1
-
- // Make a backwards pass over all blocks
- for k := len(lv.f.Blocks) - 1; k >= 0; k-- {
- b := lv.f.Blocks[k]
- be := lv.blockEffects(b)
-
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=-= liveout from tail of b%d: ", k)
- for j := range lv.vars {
- if be.liveout.Get(int32(j)) {
- fmt.Fprintf(os.Stderr, " %q", lv.vars[j].Sym().Name)
- }
- }
- fmt.Fprintf(os.Stderr, "\n")
- }
-
- // Take into account effects taking place at end of this basic
- // block by comparing our current live set with liveout for
- // the block. If a given var was not live before and is now
- // becoming live we need to mark this transition with a
- // builder "Live" call; similarly if a var was live before and
- // is now no longer live, we need a "Kill" call.
- for j := range lv.vars {
- isLive := liveout.Get(int32(j))
- blockLiveOut := be.liveout.Get(int32(j))
- if isLive {
- if !blockLiveOut {
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=+= at instr %d block boundary kill of %v\n", iidx, lv.vars[j])
- }
- cs.ibuilders[j].Kill(iidx)
- }
- } else if blockLiveOut {
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=+= at block-end instr %d %v becomes live\n",
- iidx, lv.vars[j])
- }
- cs.ibuilders[j].Live(iidx)
- }
- }
-
- // Set our working "currently live" set to the previously
- // computed live out set for the block.
- liveout.Copy(be.liveout)
-
- // Now walk backwards through this block.
- for i := len(b.Values) - 1; i >= 0; i-- {
- v := b.Values[i]
-
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=-= b%d instr %d: %s\n", k, iidx, v.LongString())
- }
-
- // Update liveness based on what we see happening in this
- // instruction.
- pos, e := lv.valueEffects(v)
- becomeslive := e&uevar != 0
- iskilled := e&varkill != 0
- if becomeslive && iskilled {
- // we do not ever expect to see both a kill and an
- // upwards exposed use given our size constraints.
- panic("should never happen")
- }
- if iskilled && liveout.Get(pos) {
- cs.ibuilders[pos].Kill(iidx)
- liveout.Unset(pos)
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=+= at instr %d kill of %v\n",
- iidx, lv.vars[pos])
- }
- } else if becomeslive && !liveout.Get(pos) {
- cs.ibuilders[pos].Live(iidx)
- liveout.Set(pos)
- if base.Debug.MergeLocalsTrace > 2 {
- fmt.Fprintf(os.Stderr, "=+= at instr %d upwards-exposed use of %v\n",
- iidx, lv.vars[pos])
- }
- }
- iidx--
- }
-
- if b == lv.f.Entry {
- for j, v := range lv.vars {
- if liveout.Get(int32(j)) {
- lv.f.Fatalf("%v %L recorded as live on entry",
- lv.fn.Nname, v)
- }
- }
- }
- }
- if iidx != -1 {
- panic("iidx underflow")
- }
-}
-
-func dumpCand(c *ir.Name, i int) {
- fmtFullPos := func(p src.XPos) string {
- var sb strings.Builder
- sep := ""
- base.Ctxt.AllPos(p, func(pos src.Pos) {
- fmt.Fprintf(&sb, sep)
- sep = "|"
- file := filepath.Base(pos.Filename())
- fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
- })
- return sb.String()
- }
- fmt.Fprintf(os.Stderr, " %d: %s %q sz=%d hp=%v t=%v\n",
- i, fmtFullPos(c.Pos()), c.Sym().Name, c.Type().Size(),
- c.Type().HasPointers(), c.Type())
-}
-
-// for unit testing only.
-func MakeMergeLocalsState(partition map[*ir.Name][]int, vars []*ir.Name) (*MergeLocalsState, error) {
- mls := &MergeLocalsState{partition: partition, vars: vars}
- if err := mls.check(); err != nil {
- return nil, err
- }
- return mls, nil
-}
doClobber bool // Whether to clobber dead stack slots in this function.
noClobberArgs bool // Do not clobber function arguments
-
- // treat "dead" writes as equivalent to reads during the analysis;
- // used only during liveness analysis for stack slot merging (doesn't
- // make sense for stackmap analysis).
- conservativeWrites bool
}
// Map maps from *ssa.Value to StackMapIndex.
if e&(ssa.SymRead|ssa.SymAddr) != 0 {
effect |= uevar
}
- if e&ssa.SymWrite != 0 {
- if !isfat(n.Type()) || v.Op == ssa.OpVarDef {
- effect |= varkill
- } else if lv.conservativeWrites {
- effect |= uevar
- }
+ if e&ssa.SymWrite != 0 && (!isfat(n.Type()) || v.Op == ssa.OpVarDef) {
+ effect |= varkill
}
if effect == 0 {
// this argument and the in arguments are always assumed live. The vars
// argument is a slice of *Nodes.
func (lv *liveness) pointerMap(liveout bitvec.BitVec, vars []*ir.Name, args, locals bitvec.BitVec) {
- var slotsSeen map[int64]*ir.Name
- checkForDuplicateSlots := base.Debug.MergeLocals != 0
- if checkForDuplicateSlots {
- slotsSeen = make(map[int64]*ir.Name)
- }
for i := int32(0); ; i++ {
i = liveout.Next(i)
if i < 0 {
fallthrough // PPARAMOUT in registers acts memory-allocates like an AUTO
case ir.PAUTO:
typebits.Set(node.Type(), node.FrameOffset()+lv.stkptrsize, locals)
- if checkForDuplicateSlots {
- if prev, ok := slotsSeen[node.FrameOffset()]; ok {
- base.FatalfAt(node.Pos(), "two vars live at pointerMap generation: %q and %q", prev.Sym().Name, node.Sym().Name)
- }
- slotsSeen[node.FrameOffset()] = node
- }
}
}
}
f.Fatalf("bad arg 1 type to %s: want integer, have %s", v.Op, v.Args[1].LongString())
}
case OpVarDef:
- n := v.Aux.(*ir.Name)
- if !n.Type().HasPointers() && !IsMergeCandidate(n) {
- f.Fatalf("vardef must be merge candidate or have pointer type %s", v.Aux.(*ir.Name).Type().String())
+ if !v.Aux.(*ir.Name).Type().HasPointers() {
+ f.Fatalf("vardef must have pointer type %s", v.Aux.(*ir.Name).Type().String())
}
case OpNilCheck:
// nil checks have pointer type before scheduling, and
// NewLocal returns a new anonymous local variable of the given type.
func (f *Func) NewLocal(pos src.XPos, typ *types.Type) *ir.Name {
- nn := typecheck.TempAt(pos, f.fe.Func(), typ) // Note: adds new auto to fn.Dcl list
- nn.SetNonMergeable(true)
- return nn
-}
-
-// IsMergeCandidate returns true if variable n could participate in
-// stack slot merging. For now we're restricting the set to things to
-// items larger than what CanSSA would allow (approximateky, we disallow things
-// marked as open defer slots so as to avoid complicating liveness
-// analysis.
-func IsMergeCandidate(n *ir.Name) bool {
- if base.Debug.MergeLocals == 0 ||
- base.Flag.N != 0 ||
- n.Class != ir.PAUTO ||
- n.Type().Size() <= int64(3*types.PtrSize) ||
- n.Addrtaken() ||
- n.NonMergeable() ||
- n.OpenDeferSlot() {
- return false
- }
- return true
+ return typecheck.TempAt(pos, f.fe.Func(), typ) // Note: adds new auto to fn.Dcl list
}
"cmd/compile/internal/base"
"cmd/compile/internal/ir"
- "cmd/compile/internal/liveness"
"cmd/compile/internal/objw"
"cmd/compile/internal/ssa"
"cmd/compile/internal/types"
}
}
- var mls *liveness.MergeLocalsState
- if base.Debug.MergeLocals != 0 {
- mls = liveness.MergeLocals(fn, f)
- if base.Debug.MergeLocalsTrace == 1 && mls != nil {
- fmt.Fprintf(os.Stderr, "%s: %d bytes of stack space saved via stack slot merging\n", ir.FuncName(fn), mls.EstSavings())
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= merge locals state for %v:\n%v",
- fn, mls)
- }
- }
- }
-
// Use sort.SliceStable instead of sort.Slice so stack layout (and thus
// compiler output) is less sensitive to frontend changes that
// introduce or remove unused variables.
return cmpstackvarlt(fn.Dcl[i], fn.Dcl[j])
})
- if base.Debug.MergeLocalsTrace > 1 && mls != nil {
- fmt.Fprintf(os.Stderr, "=-= sorted DCL for %v:\n", fn)
- for i, v := range fn.Dcl {
- if !ssa.IsMergeCandidate(v) {
- continue
- }
- fmt.Fprintf(os.Stderr, " %d: %q isleader=%v subsumed=%v used=%v\n", i, v.Sym().Name, mls.IsLeader(v), mls.Subsumed(v), v.Used())
-
- }
- }
-
- var leaders map[*ir.Name]int64
- if mls != nil {
- leaders = make(map[*ir.Name]int64)
- }
-
// Reassign stack offsets of the locals that are used.
lastHasPtr := false
for i, n := range fn.Dcl {
// i.e., stack assign if AUTO, or if PARAMOUT in registers (which has no predefined spill locations)
continue
}
- if mls != nil && mls.Subsumed(n) {
- continue
- }
if !n.Used() {
fn.DebugInfo.(*ssa.FuncDebug).OptDcl = fn.Dcl[i:]
fn.Dcl = fn.Dcl[:i]
break
}
+
types.CalcSize(n.Type())
w := n.Type().Size()
if w >= types.MaxWidth || w < 0 {
lastHasPtr = false
}
n.SetFrameOffset(-s.stksize)
- if mls != nil && mls.IsLeader(n) {
- leaders[n] = -s.stksize
- }
- }
-
- if mls != nil {
- followers := []*ir.Name{}
- newdcl := make([]*ir.Name, 0, len(fn.Dcl))
- for i := 0; i < len(fn.Dcl); i++ {
- n := fn.Dcl[i]
- if mls.Subsumed(n) {
- continue
- }
- newdcl = append(newdcl, n)
- if off, ok := leaders[n]; ok {
- followers = mls.Followers(n, followers)
- for _, f := range followers {
- // Set the stack offset for each follower to be
- // the same as the leader.
- f.SetFrameOffset(off)
- }
- // position followers immediately after leader
- newdcl = append(newdcl, followers...)
- }
- }
- fn.Dcl = newdcl
- }
-
- if base.Debug.MergeLocalsTrace > 1 {
- fmt.Fprintf(os.Stderr, "=-= stack layout for %v:\n", fn)
- for i, v := range fn.Dcl {
- if v.Op() != ir.ONAME || (v.Class != ir.PAUTO && !(v.Class == ir.PPARAMOUT && v.IsOutputParamInRegisters())) {
- continue
- }
- fmt.Fprintf(os.Stderr, " %d: %q frameoff %d used=%v\n", i, v.Sym().Name, v.FrameOffset(), v.Used())
- }
}
s.stksize = types.RoundUp(s.stksize, s.stkalign)
if typ := n.Type(); ssa.CanSSA(typ) {
s.assign(n, s.zeroVal(typ), false, 0)
} else {
- if typ.HasPointers() || ssa.IsMergeCandidate(n) {
+ if typ.HasPointers() {
s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, n, s.mem())
}
s.zero(n.Type(), s.decladdrs[n])
// If this assignment clobbers an entire local variable, then emit
// OpVarDef so liveness analysis knows the variable is redefined.
- if base, ok := clobberBase(left).(*ir.Name); ok && base.OnStack() && skip == 0 && (t.HasPointers() || ssa.IsMergeCandidate(base)) {
+ if base, ok := clobberBase(left).(*ir.Name); ok && base.OnStack() && skip == 0 && t.HasPointers() {
s.vars[memVar] = s.newValue1Apos(ssa.OpVarDef, types.TypeMem, base, s.mem(), !ir.IsAutoTmp(base))
}
}
// Make a defer struct on the stack.
t := deferstruct()
- n, addr := s.temp(n.Pos(), t)
- n.SetNonMergeable(true)
+ _, addr := s.temp(n.Pos(), t)
s.store(closure.Type,
s.newValue1I(ssa.OpOffPtr, closure.Type.PtrTo(), t.FieldOff(deferStructFnField), addr),
closure)
// temp allocates a temp of type t at position pos
func (s *state) temp(pos src.XPos, t *types.Type) (*ir.Name, *ssa.Value) {
tmp := typecheck.TempAt(pos, s.curfn, t)
- if t.HasPointers() || (ssa.IsMergeCandidate(tmp) && t != deferstruct()) {
+ if t.HasPointers() {
s.vars[memVar] = s.newValue1A(ssa.OpVarDef, types.TypeMem, tmp, s.mem())
}
addr := s.addr(tmp)
+++ /dev/null
-// Copyright 2024 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 test
-
-import (
- "cmd/compile/internal/ir"
- "cmd/compile/internal/liveness"
- "cmd/compile/internal/typecheck"
- "cmd/compile/internal/types"
- "cmd/internal/src"
- "internal/testenv"
- "path/filepath"
- "slices"
- "sort"
- "strings"
- "testing"
-)
-
-func TestMergeLocalState(t *testing.T) {
- mkiv := func(name string) *ir.Name {
- i32 := types.Types[types.TINT32]
- s := typecheck.Lookup(name)
- v := ir.NewNameAt(src.NoXPos, s, i32)
- return v
- }
- v1 := mkiv("v1")
- v2 := mkiv("v2")
- v3 := mkiv("v3")
-
- testcases := []struct {
- vars []*ir.Name
- partition map[*ir.Name][]int
- experr bool
- }{
- {
- vars: []*ir.Name{v1, v2, v3},
- partition: map[*ir.Name][]int{
- v1: []int{0, 1, 2},
- v2: []int{0, 1, 2},
- v3: []int{0, 1, 2},
- },
- experr: false,
- },
- {
- // invalid mls.v slot -1
- vars: []*ir.Name{v1, v2, v3},
- partition: map[*ir.Name][]int{
- v1: []int{-1, 0},
- v2: []int{0, 1, 2},
- v3: []int{0, 1, 2},
- },
- experr: true,
- },
- {
- // duplicate var in v
- vars: []*ir.Name{v1, v2, v2},
- partition: map[*ir.Name][]int{
- v1: []int{0, 1, 2},
- v2: []int{0, 1, 2},
- v3: []int{0, 1, 2},
- },
- experr: true,
- },
- {
- // single element in partition
- vars: []*ir.Name{v1, v2, v3},
- partition: map[*ir.Name][]int{
- v1: []int{0},
- v2: []int{0, 1, 2},
- v3: []int{0, 1, 2},
- },
- experr: true,
- },
- {
- // missing element 2
- vars: []*ir.Name{v1, v2, v3},
- partition: map[*ir.Name][]int{
- v1: []int{0, 1},
- v2: []int{0, 1},
- v3: []int{0, 1},
- },
- experr: true,
- },
- {
- // partitions disagree for v1 vs v2
- vars: []*ir.Name{v1, v2, v3},
- partition: map[*ir.Name][]int{
- v1: []int{0, 1, 2},
- v2: []int{1, 0, 2},
- v3: []int{0, 1, 2},
- },
- experr: true,
- },
- }
-
- for k, testcase := range testcases {
- mls, err := liveness.MakeMergeLocalsState(testcase.partition, testcase.vars)
- t.Logf("tc %d err is %v\n", k, err)
- if testcase.experr && err == nil {
- t.Fatalf("tc:%d missing error mls %v", k, mls)
- } else if !testcase.experr && err != nil {
- t.Fatalf("tc:%d unexpected error mls %v", k, err)
- }
- if mls != nil {
- t.Logf("tc %d: mls: %v\n", k, mls.String())
- }
- }
-}
-
-func TestMergeLocalsIntegration(t *testing.T) {
- testenv.MustHaveGoBuild(t)
-
- // This test does a build of a specific canned package to
- // check whether merging of stack slots is taking place.
- // The idea is to do the compile with a trace option turned
- // on and then pick up on the frame offsets of specific
- // variables.
- //
- // Stack slot merging is a greedy algorithm, and there can
- // be many possible ways to overlap a given set of candidate
- // variables, all of them legal. Rather than locking down
- // a specific set of overlappings or frame offsets, this
- // tests just verifies that there is one clump of 3 vars that
- // get overlapped, then another clump of 2 that share the same
- // frame offset.
- //
- // The expected output blob we're interested in looks like this:
- //
- // =-= stack layout for ABC:
- // 2: "p1" frameoff -8200 used=true
- // 3: "xp3" frameoff -8200 used=true
- // 4: "xp4" frameoff -8200 used=true
- // 5: "p2" frameoff -16400 used=true
- // 6: "s" frameoff -24592 used=true
- // 7: "v1" frameoff -32792 used=true
- // 8: "v3" frameoff -32792 used=true
- // 9: "v2" frameoff -40992 used=true
- //
- tmpdir := t.TempDir()
- src := filepath.Join("testdata", "mergelocals", "integration.go")
- obj := filepath.Join(tmpdir, "p.a")
- out, err := testenv.Command(t, testenv.GoToolPath(t), "tool", "compile", "-p=p", "-c", "1", "-o", obj, "-d=mergelocalstrace=2,mergelocals=1", src).CombinedOutput()
- if err != nil {
- t.Fatalf("failed to compile: %v\n%s", err, out)
- }
- vars := make(map[string]string)
- lines := strings.Split(string(out), "\n")
- prolog := true
- varsAtFrameOffset := make(map[string]int)
- for _, line := range lines {
- if line == "=-= stack layout for ABC:" {
- prolog = false
- continue
- } else if prolog || line == "" {
- continue
- }
- fields := strings.Fields(line)
- if len(fields) != 5 {
- t.Fatalf("bad trace output line: %s", line)
- }
- vname := fields[1]
- frameoff := fields[3]
- varsAtFrameOffset[frameoff] = varsAtFrameOffset[frameoff] + 1
- vars[vname] = frameoff
- }
- wantvnum := 8
- gotvnum := len(vars)
- if wantvnum != gotvnum {
- t.Fatalf("expected trace output on %d vars got %d\n", wantvnum, gotvnum)
- }
-
- // We expect one clump of 3, another clump of 2, and the rest singletons.
- expected := []int{1, 1, 1, 2, 3}
- got := []int{}
- for _, v := range varsAtFrameOffset {
- got = append(got, v)
- }
- sort.Ints(got)
- if !slices.Equal(got, expected) {
- t.Fatalf("expected variable clumps %+v not equal to what we got: %+v", expected, got)
- }
-}
+++ /dev/null
-// Copyright 2024 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
-
-// This type and the following one will share the same GC shape and size.
-type Pointery struct {
- p *Pointery
- x [1024]int
-}
-
-type Pointery2 struct {
- p *Pointery2
- x [1024]int
-}
-
-// This type and the following one will have the same size.
-type Vanilla struct {
- np uintptr
- x [1024]int
-}
-
-type Vanilla2 struct {
- np uintptr
- x [1023]int
- y int
-}
-
-type Single struct {
- np uintptr
- x [1023]int
-}
-
-func ABC(i, j int) int {
- r := 0
-
- // here v1 interferes with v2 but could be overlapped with v3.
- // we can also overlap v1 with v3.
- var v1 Vanilla
- if i < 101 {
- var v2 Vanilla
- v1.x[i] = j
- r += v1.x[j]
- v2.x[i] = j
- r += v2.x[j]
- }
-
- {
- var v3 Vanilla2
- v3.x[i] = j
- r += v3.x[j]
- }
-
- var s Single
- s.x[i] = j
- r += s.x[j]
-
- // Here p1 and p2 interfere, but p1 could be overlapped with xp3.
- var p1, p2 Pointery
- p1.x[i] = j
- r += p1.x[j]
- p2.x[i] = j
- r += p2.x[j]
- {
- var xp3 Pointery2
- xp3.x[i] = j
- r += xp3.x[j]
- }
-
- if i == j*2 {
- // p2 live on this path
- p2.x[i] += j
- r += p2.x[j]
- } else {
- // p2 not live on this path
- var xp4 Pointery2
- xp4.x[i] = j
- r += xp4.x[j]
- }
-
- return r
-}
// allocated temporary variable of the given type. Statements to
// zero-initialize tmp are appended to init.
func stackTempAddr(init *ir.Nodes, typ *types.Type) *ir.AddrExpr {
- n := typecheck.TempAt(base.Pos, ir.CurFunc, typ)
- n.SetNonMergeable(true)
- return initStackTemp(init, n, nil)
+ return initStackTemp(init, typecheck.TempAt(base.Pos, ir.CurFunc, typ), nil)
}
// stackBufAddr returns the expression &tmp, where tmp is a newly
package main
-var z [10 << 20]byte
+var z [10<<20]byte
func main() { // GC_ERROR "stack frame too large"
- // seq 1 206 | sed 's/.*/ var x& [10<<20]byte/'
- // seq 1 206 | sed 's/.*/ z = x&/'
- var x1 [10<<20]byte
- var x2 [10<<20]byte
- var x3 [10<<20]byte
- var x4 [10<<20]byte
- var x5 [10<<20]byte
- var x6 [10<<20]byte
- var x7 [10<<20]byte
- var x8 [10<<20]byte
- var x9 [10<<20]byte
- var x10 [10<<20]byte
- var x11 [10<<20]byte
- var x12 [10<<20]byte
- var x13 [10<<20]byte
- var x14 [10<<20]byte
- var x15 [10<<20]byte
- var x16 [10<<20]byte
- var x17 [10<<20]byte
- var x18 [10<<20]byte
- var x19 [10<<20]byte
- var x20 [10<<20]byte
- var x21 [10<<20]byte
- var x22 [10<<20]byte
- var x23 [10<<20]byte
- var x24 [10<<20]byte
- var x25 [10<<20]byte
- var x26 [10<<20]byte
- var x27 [10<<20]byte
- var x28 [10<<20]byte
- var x29 [10<<20]byte
- var x30 [10<<20]byte
- var x31 [10<<20]byte
- var x32 [10<<20]byte
- var x33 [10<<20]byte
- var x34 [10<<20]byte
- var x35 [10<<20]byte
- var x36 [10<<20]byte
- var x37 [10<<20]byte
- var x38 [10<<20]byte
- var x39 [10<<20]byte
- var x40 [10<<20]byte
- var x41 [10<<20]byte
- var x42 [10<<20]byte
- var x43 [10<<20]byte
- var x44 [10<<20]byte
- var x45 [10<<20]byte
- var x46 [10<<20]byte
- var x47 [10<<20]byte
- var x48 [10<<20]byte
- var x49 [10<<20]byte
- var x50 [10<<20]byte
- var x51 [10<<20]byte
- var x52 [10<<20]byte
- var x53 [10<<20]byte
- var x54 [10<<20]byte
- var x55 [10<<20]byte
- var x56 [10<<20]byte
- var x57 [10<<20]byte
- var x58 [10<<20]byte
- var x59 [10<<20]byte
- var x60 [10<<20]byte
- var x61 [10<<20]byte
- var x62 [10<<20]byte
- var x63 [10<<20]byte
- var x64 [10<<20]byte
- var x65 [10<<20]byte
- var x66 [10<<20]byte
- var x67 [10<<20]byte
- var x68 [10<<20]byte
- var x69 [10<<20]byte
- var x70 [10<<20]byte
- var x71 [10<<20]byte
- var x72 [10<<20]byte
- var x73 [10<<20]byte
- var x74 [10<<20]byte
- var x75 [10<<20]byte
- var x76 [10<<20]byte
- var x77 [10<<20]byte
- var x78 [10<<20]byte
- var x79 [10<<20]byte
- var x80 [10<<20]byte
- var x81 [10<<20]byte
- var x82 [10<<20]byte
- var x83 [10<<20]byte
- var x84 [10<<20]byte
- var x85 [10<<20]byte
- var x86 [10<<20]byte
- var x87 [10<<20]byte
- var x88 [10<<20]byte
- var x89 [10<<20]byte
- var x90 [10<<20]byte
- var x91 [10<<20]byte
- var x92 [10<<20]byte
- var x93 [10<<20]byte
- var x94 [10<<20]byte
- var x95 [10<<20]byte
- var x96 [10<<20]byte
- var x97 [10<<20]byte
- var x98 [10<<20]byte
- var x99 [10<<20]byte
- var x100 [10<<20]byte
- var x101 [10<<20]byte
- var x102 [10<<20]byte
- var x103 [10<<20]byte
- var x104 [10<<20]byte
- var x105 [10<<20]byte
- var x106 [10<<20]byte
- var x107 [10<<20]byte
- var x108 [10<<20]byte
- var x109 [10<<20]byte
- var x110 [10<<20]byte
- var x111 [10<<20]byte
- var x112 [10<<20]byte
- var x113 [10<<20]byte
- var x114 [10<<20]byte
- var x115 [10<<20]byte
- var x116 [10<<20]byte
- var x117 [10<<20]byte
- var x118 [10<<20]byte
- var x119 [10<<20]byte
- var x120 [10<<20]byte
- var x121 [10<<20]byte
- var x122 [10<<20]byte
- var x123 [10<<20]byte
- var x124 [10<<20]byte
- var x125 [10<<20]byte
- var x126 [10<<20]byte
- var x127 [10<<20]byte
- var x128 [10<<20]byte
- var x129 [10<<20]byte
- var x130 [10<<20]byte
- var x131 [10<<20]byte
- var x132 [10<<20]byte
- var x133 [10<<20]byte
- var x134 [10<<20]byte
- var x135 [10<<20]byte
- var x136 [10<<20]byte
- var x137 [10<<20]byte
- var x138 [10<<20]byte
- var x139 [10<<20]byte
- var x140 [10<<20]byte
- var x141 [10<<20]byte
- var x142 [10<<20]byte
- var x143 [10<<20]byte
- var x144 [10<<20]byte
- var x145 [10<<20]byte
- var x146 [10<<20]byte
- var x147 [10<<20]byte
- var x148 [10<<20]byte
- var x149 [10<<20]byte
- var x150 [10<<20]byte
- var x151 [10<<20]byte
- var x152 [10<<20]byte
- var x153 [10<<20]byte
- var x154 [10<<20]byte
- var x155 [10<<20]byte
- var x156 [10<<20]byte
- var x157 [10<<20]byte
- var x158 [10<<20]byte
- var x159 [10<<20]byte
- var x160 [10<<20]byte
- var x161 [10<<20]byte
- var x162 [10<<20]byte
- var x163 [10<<20]byte
- var x164 [10<<20]byte
- var x165 [10<<20]byte
- var x166 [10<<20]byte
- var x167 [10<<20]byte
- var x168 [10<<20]byte
- var x169 [10<<20]byte
- var x170 [10<<20]byte
- var x171 [10<<20]byte
- var x172 [10<<20]byte
- var x173 [10<<20]byte
- var x174 [10<<20]byte
- var x175 [10<<20]byte
- var x176 [10<<20]byte
- var x177 [10<<20]byte
- var x178 [10<<20]byte
- var x179 [10<<20]byte
- var x180 [10<<20]byte
- var x181 [10<<20]byte
- var x182 [10<<20]byte
- var x183 [10<<20]byte
- var x184 [10<<20]byte
- var x185 [10<<20]byte
- var x186 [10<<20]byte
- var x187 [10<<20]byte
- var x188 [10<<20]byte
- var x189 [10<<20]byte
- var x190 [10<<20]byte
- var x191 [10<<20]byte
- var x192 [10<<20]byte
- var x193 [10<<20]byte
- var x194 [10<<20]byte
- var x195 [10<<20]byte
- var x196 [10<<20]byte
- var x197 [10<<20]byte
- var x198 [10<<20]byte
- var x199 [10<<20]byte
- var x200 [10<<20]byte
- var x201 [10<<20]byte
- var x202 [10<<20]byte
- var x203 [10<<20]byte
- var x204 [10<<20]byte
- var x205 [10<<20]byte
- var x206 [10<<20]byte
- var x207 [10<<20]byte
- z = x1
- z = x2
- z = x3
- z = x4
- z = x5
- z = x6
- z = x7
- z = x8
- z = x9
- z = x10
- z = x11
- z = x12
- z = x13
- z = x14
- z = x15
- z = x16
- z = x17
- z = x18
- z = x19
- z = x20
- z = x21
- z = x22
- z = x23
- z = x24
- z = x25
- z = x26
- z = x27
- z = x28
- z = x29
- z = x30
- z = x31
- z = x32
- z = x33
- z = x34
- z = x35
- z = x36
- z = x37
- z = x38
- z = x39
- z = x40
- z = x41
- z = x42
- z = x43
- z = x44
- z = x45
- z = x46
- z = x47
- z = x48
- z = x49
- z = x50
- z = x51
- z = x52
- z = x53
- z = x54
- z = x55
- z = x56
- z = x57
- z = x58
- z = x59
- z = x60
- z = x61
- z = x62
- z = x63
- z = x64
- z = x65
- z = x66
- z = x67
- z = x68
- z = x69
- z = x70
- z = x71
- z = x72
- z = x73
- z = x74
- z = x75
- z = x76
- z = x77
- z = x78
- z = x79
- z = x80
- z = x81
- z = x82
- z = x83
- z = x84
- z = x85
- z = x86
- z = x87
- z = x88
- z = x89
- z = x90
- z = x91
- z = x92
- z = x93
- z = x94
- z = x95
- z = x96
- z = x97
- z = x98
- z = x99
- z = x100
- z = x101
- z = x102
- z = x103
- z = x104
- z = x105
- z = x106
- z = x107
- z = x108
- z = x109
- z = x110
- z = x111
- z = x112
- z = x113
- z = x114
- z = x115
- z = x116
- z = x117
- z = x118
- z = x119
- z = x120
- z = x121
- z = x122
- z = x123
- z = x124
- z = x125
- z = x126
- z = x127
- z = x128
- z = x129
- z = x130
- z = x131
- z = x132
- z = x133
- z = x134
- z = x135
- z = x136
- z = x137
- z = x138
- z = x139
- z = x140
- z = x141
- z = x142
- z = x143
- z = x144
- z = x145
- z = x146
- z = x147
- z = x148
- z = x149
- z = x150
- z = x151
- z = x152
- z = x153
- z = x154
- z = x155
- z = x156
- z = x157
- z = x158
- z = x159
- z = x160
- z = x161
- z = x162
- z = x163
- z = x164
- z = x165
- z = x166
- z = x167
- z = x168
- z = x169
- z = x170
- z = x171
- z = x172
- z = x173
- z = x174
- z = x175
- z = x176
- z = x177
- z = x178
- z = x179
- z = x180
- z = x181
- z = x182
- z = x183
- z = x184
- z = x185
- z = x186
- z = x187
- z = x188
- z = x189
- z = x190
- z = x191
- z = x192
- z = x193
- z = x194
- z = x195
- z = x196
- z = x197
- z = x198
- z = x199
- z = x200
- z = x201
- z = x202
- z = x203
- z = x204
- z = x205
- z = x206
- z = x207
+ // seq 1 206 | sed 's/.*/ var x& [10<<20]byte; z = x&/'
+ var x1 [10<<20]byte; z = x1
+ var x2 [10<<20]byte; z = x2
+ var x3 [10<<20]byte; z = x3
+ var x4 [10<<20]byte; z = x4
+ var x5 [10<<20]byte; z = x5
+ var x6 [10<<20]byte; z = x6
+ var x7 [10<<20]byte; z = x7
+ var x8 [10<<20]byte; z = x8
+ var x9 [10<<20]byte; z = x9
+ var x10 [10<<20]byte; z = x10
+ var x11 [10<<20]byte; z = x11
+ var x12 [10<<20]byte; z = x12
+ var x13 [10<<20]byte; z = x13
+ var x14 [10<<20]byte; z = x14
+ var x15 [10<<20]byte; z = x15
+ var x16 [10<<20]byte; z = x16
+ var x17 [10<<20]byte; z = x17
+ var x18 [10<<20]byte; z = x18
+ var x19 [10<<20]byte; z = x19
+ var x20 [10<<20]byte; z = x20
+ var x21 [10<<20]byte; z = x21
+ var x22 [10<<20]byte; z = x22
+ var x23 [10<<20]byte; z = x23
+ var x24 [10<<20]byte; z = x24
+ var x25 [10<<20]byte; z = x25
+ var x26 [10<<20]byte; z = x26
+ var x27 [10<<20]byte; z = x27
+ var x28 [10<<20]byte; z = x28
+ var x29 [10<<20]byte; z = x29
+ var x30 [10<<20]byte; z = x30
+ var x31 [10<<20]byte; z = x31
+ var x32 [10<<20]byte; z = x32
+ var x33 [10<<20]byte; z = x33
+ var x34 [10<<20]byte; z = x34
+ var x35 [10<<20]byte; z = x35
+ var x36 [10<<20]byte; z = x36
+ var x37 [10<<20]byte; z = x37
+ var x38 [10<<20]byte; z = x38
+ var x39 [10<<20]byte; z = x39
+ var x40 [10<<20]byte; z = x40
+ var x41 [10<<20]byte; z = x41
+ var x42 [10<<20]byte; z = x42
+ var x43 [10<<20]byte; z = x43
+ var x44 [10<<20]byte; z = x44
+ var x45 [10<<20]byte; z = x45
+ var x46 [10<<20]byte; z = x46
+ var x47 [10<<20]byte; z = x47
+ var x48 [10<<20]byte; z = x48
+ var x49 [10<<20]byte; z = x49
+ var x50 [10<<20]byte; z = x50
+ var x51 [10<<20]byte; z = x51
+ var x52 [10<<20]byte; z = x52
+ var x53 [10<<20]byte; z = x53
+ var x54 [10<<20]byte; z = x54
+ var x55 [10<<20]byte; z = x55
+ var x56 [10<<20]byte; z = x56
+ var x57 [10<<20]byte; z = x57
+ var x58 [10<<20]byte; z = x58
+ var x59 [10<<20]byte; z = x59
+ var x60 [10<<20]byte; z = x60
+ var x61 [10<<20]byte; z = x61
+ var x62 [10<<20]byte; z = x62
+ var x63 [10<<20]byte; z = x63
+ var x64 [10<<20]byte; z = x64
+ var x65 [10<<20]byte; z = x65
+ var x66 [10<<20]byte; z = x66
+ var x67 [10<<20]byte; z = x67
+ var x68 [10<<20]byte; z = x68
+ var x69 [10<<20]byte; z = x69
+ var x70 [10<<20]byte; z = x70
+ var x71 [10<<20]byte; z = x71
+ var x72 [10<<20]byte; z = x72
+ var x73 [10<<20]byte; z = x73
+ var x74 [10<<20]byte; z = x74
+ var x75 [10<<20]byte; z = x75
+ var x76 [10<<20]byte; z = x76
+ var x77 [10<<20]byte; z = x77
+ var x78 [10<<20]byte; z = x78
+ var x79 [10<<20]byte; z = x79
+ var x80 [10<<20]byte; z = x80
+ var x81 [10<<20]byte; z = x81
+ var x82 [10<<20]byte; z = x82
+ var x83 [10<<20]byte; z = x83
+ var x84 [10<<20]byte; z = x84
+ var x85 [10<<20]byte; z = x85
+ var x86 [10<<20]byte; z = x86
+ var x87 [10<<20]byte; z = x87
+ var x88 [10<<20]byte; z = x88
+ var x89 [10<<20]byte; z = x89
+ var x90 [10<<20]byte; z = x90
+ var x91 [10<<20]byte; z = x91
+ var x92 [10<<20]byte; z = x92
+ var x93 [10<<20]byte; z = x93
+ var x94 [10<<20]byte; z = x94
+ var x95 [10<<20]byte; z = x95
+ var x96 [10<<20]byte; z = x96
+ var x97 [10<<20]byte; z = x97
+ var x98 [10<<20]byte; z = x98
+ var x99 [10<<20]byte; z = x99
+ var x100 [10<<20]byte; z = x100
+ var x101 [10<<20]byte; z = x101
+ var x102 [10<<20]byte; z = x102
+ var x103 [10<<20]byte; z = x103
+ var x104 [10<<20]byte; z = x104
+ var x105 [10<<20]byte; z = x105
+ var x106 [10<<20]byte; z = x106
+ var x107 [10<<20]byte; z = x107
+ var x108 [10<<20]byte; z = x108
+ var x109 [10<<20]byte; z = x109
+ var x110 [10<<20]byte; z = x110
+ var x111 [10<<20]byte; z = x111
+ var x112 [10<<20]byte; z = x112
+ var x113 [10<<20]byte; z = x113
+ var x114 [10<<20]byte; z = x114
+ var x115 [10<<20]byte; z = x115
+ var x116 [10<<20]byte; z = x116
+ var x117 [10<<20]byte; z = x117
+ var x118 [10<<20]byte; z = x118
+ var x119 [10<<20]byte; z = x119
+ var x120 [10<<20]byte; z = x120
+ var x121 [10<<20]byte; z = x121
+ var x122 [10<<20]byte; z = x122
+ var x123 [10<<20]byte; z = x123
+ var x124 [10<<20]byte; z = x124
+ var x125 [10<<20]byte; z = x125
+ var x126 [10<<20]byte; z = x126
+ var x127 [10<<20]byte; z = x127
+ var x128 [10<<20]byte; z = x128
+ var x129 [10<<20]byte; z = x129
+ var x130 [10<<20]byte; z = x130
+ var x131 [10<<20]byte; z = x131
+ var x132 [10<<20]byte; z = x132
+ var x133 [10<<20]byte; z = x133
+ var x134 [10<<20]byte; z = x134
+ var x135 [10<<20]byte; z = x135
+ var x136 [10<<20]byte; z = x136
+ var x137 [10<<20]byte; z = x137
+ var x138 [10<<20]byte; z = x138
+ var x139 [10<<20]byte; z = x139
+ var x140 [10<<20]byte; z = x140
+ var x141 [10<<20]byte; z = x141
+ var x142 [10<<20]byte; z = x142
+ var x143 [10<<20]byte; z = x143
+ var x144 [10<<20]byte; z = x144
+ var x145 [10<<20]byte; z = x145
+ var x146 [10<<20]byte; z = x146
+ var x147 [10<<20]byte; z = x147
+ var x148 [10<<20]byte; z = x148
+ var x149 [10<<20]byte; z = x149
+ var x150 [10<<20]byte; z = x150
+ var x151 [10<<20]byte; z = x151
+ var x152 [10<<20]byte; z = x152
+ var x153 [10<<20]byte; z = x153
+ var x154 [10<<20]byte; z = x154
+ var x155 [10<<20]byte; z = x155
+ var x156 [10<<20]byte; z = x156
+ var x157 [10<<20]byte; z = x157
+ var x158 [10<<20]byte; z = x158
+ var x159 [10<<20]byte; z = x159
+ var x160 [10<<20]byte; z = x160
+ var x161 [10<<20]byte; z = x161
+ var x162 [10<<20]byte; z = x162
+ var x163 [10<<20]byte; z = x163
+ var x164 [10<<20]byte; z = x164
+ var x165 [10<<20]byte; z = x165
+ var x166 [10<<20]byte; z = x166
+ var x167 [10<<20]byte; z = x167
+ var x168 [10<<20]byte; z = x168
+ var x169 [10<<20]byte; z = x169
+ var x170 [10<<20]byte; z = x170
+ var x171 [10<<20]byte; z = x171
+ var x172 [10<<20]byte; z = x172
+ var x173 [10<<20]byte; z = x173
+ var x174 [10<<20]byte; z = x174
+ var x175 [10<<20]byte; z = x175
+ var x176 [10<<20]byte; z = x176
+ var x177 [10<<20]byte; z = x177
+ var x178 [10<<20]byte; z = x178
+ var x179 [10<<20]byte; z = x179
+ var x180 [10<<20]byte; z = x180
+ var x181 [10<<20]byte; z = x181
+ var x182 [10<<20]byte; z = x182
+ var x183 [10<<20]byte; z = x183
+ var x184 [10<<20]byte; z = x184
+ var x185 [10<<20]byte; z = x185
+ var x186 [10<<20]byte; z = x186
+ var x187 [10<<20]byte; z = x187
+ var x188 [10<<20]byte; z = x188
+ var x189 [10<<20]byte; z = x189
+ var x190 [10<<20]byte; z = x190
+ var x191 [10<<20]byte; z = x191
+ var x192 [10<<20]byte; z = x192
+ var x193 [10<<20]byte; z = x193
+ var x194 [10<<20]byte; z = x194
+ var x195 [10<<20]byte; z = x195
+ var x196 [10<<20]byte; z = x196
+ var x197 [10<<20]byte; z = x197
+ var x198 [10<<20]byte; z = x198
+ var x199 [10<<20]byte; z = x199
+ var x200 [10<<20]byte; z = x200
+ var x201 [10<<20]byte; z = x201
+ var x202 [10<<20]byte; z = x202
+ var x203 [10<<20]byte; z = x203
+ var x204 [10<<20]byte; z = x204
+ var x205 [10<<20]byte; z = x205
+ var x206 [10<<20]byte; z = x206
}