mirror of
https://github.com/golang/go.git
synced 2025-10-19 19:13:18 +00:00
9c5241e520
There were only a few places these were still used, none of which justify generating all this code. Instead rewrite them to use fmt.Sprint or simpler means. Passes buildall w/ toolstash -cmp. Change-Id: Ibd123a1696941a597f0cb4dcc96cda8ced672140 Reviewed-on: https://go-review.googlesource.com/c/go/+/276072 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org> Trust: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Russ Cox <rsc@golang.org>
198 lines
7.8 KiB
Go
198 lines
7.8 KiB
Go
// Copyright 2020 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.
|
|
|
|
//go:generate go run -mod=mod mknode.go
|
|
|
|
package ir
|
|
|
|
import (
|
|
"cmd/compile/internal/types"
|
|
"cmd/internal/src"
|
|
"fmt"
|
|
"go/constant"
|
|
)
|
|
|
|
// A miniNode is a minimal node implementation,
|
|
// meant to be embedded as the first field in a larger node implementation,
|
|
// at a cost of 8 bytes.
|
|
//
|
|
// A miniNode is NOT a valid Node by itself: the embedding struct
|
|
// must at the least provide:
|
|
//
|
|
// func (n *MyNode) String() string { return fmt.Sprint(n) }
|
|
// func (n *MyNode) rawCopy() Node { c := *n; return &c }
|
|
// func (n *MyNode) Format(s fmt.State, verb rune) { FmtNode(n, s, verb) }
|
|
//
|
|
// The embedding struct should also fill in n.op in its constructor,
|
|
// for more useful panic messages when invalid methods are called,
|
|
// instead of implementing Op itself.
|
|
//
|
|
type miniNode struct {
|
|
pos src.XPos // uint32
|
|
op Op // uint8
|
|
bits bitset8
|
|
esc uint16
|
|
}
|
|
|
|
func (n *miniNode) Format(s fmt.State, verb rune) { panic(1) }
|
|
func (n *miniNode) copy() Node { panic(1) }
|
|
func (n *miniNode) doChildren(do func(Node) error) error { panic(1) }
|
|
func (n *miniNode) editChildren(edit func(Node) Node) { panic(1) }
|
|
|
|
// posOr returns pos if known, or else n.pos.
|
|
// For use in DeepCopy.
|
|
func (n *miniNode) posOr(pos src.XPos) src.XPos {
|
|
if pos.IsKnown() {
|
|
return pos
|
|
}
|
|
return n.pos
|
|
}
|
|
|
|
// op can be read, but not written.
|
|
// An embedding implementation can provide a SetOp if desired.
|
|
// (The panicking SetOp is with the other panics below.)
|
|
func (n *miniNode) Op() Op { return n.op }
|
|
func (n *miniNode) Pos() src.XPos { return n.pos }
|
|
func (n *miniNode) SetPos(x src.XPos) { n.pos = x }
|
|
func (n *miniNode) Esc() uint16 { return n.esc }
|
|
func (n *miniNode) SetEsc(x uint16) { n.esc = x }
|
|
|
|
const (
|
|
miniWalkdefShift = 0
|
|
miniTypecheckShift = 2
|
|
miniInitorderShift = 4
|
|
miniDiag = 1 << 6
|
|
miniHasCall = 1 << 7 // for miniStmt
|
|
)
|
|
|
|
func (n *miniNode) Walkdef() uint8 { return n.bits.get2(miniWalkdefShift) }
|
|
func (n *miniNode) Typecheck() uint8 { return n.bits.get2(miniTypecheckShift) }
|
|
func (n *miniNode) Initorder() uint8 { return n.bits.get2(miniInitorderShift) }
|
|
func (n *miniNode) SetWalkdef(x uint8) {
|
|
if x > 3 {
|
|
panic(fmt.Sprintf("cannot SetWalkdef %d", x))
|
|
}
|
|
n.bits.set2(miniWalkdefShift, x)
|
|
}
|
|
func (n *miniNode) SetTypecheck(x uint8) {
|
|
if x > 3 {
|
|
panic(fmt.Sprintf("cannot SetTypecheck %d", x))
|
|
}
|
|
n.bits.set2(miniTypecheckShift, x)
|
|
}
|
|
func (n *miniNode) SetInitorder(x uint8) {
|
|
if x > 3 {
|
|
panic(fmt.Sprintf("cannot SetInitorder %d", x))
|
|
}
|
|
n.bits.set2(miniInitorderShift, x)
|
|
}
|
|
|
|
func (n *miniNode) Diag() bool { return n.bits&miniDiag != 0 }
|
|
func (n *miniNode) SetDiag(x bool) { n.bits.set(miniDiag, x) }
|
|
|
|
// Empty, immutable graph structure.
|
|
|
|
func (n *miniNode) Left() Node { return nil }
|
|
func (n *miniNode) Right() Node { return nil }
|
|
func (n *miniNode) Init() Nodes { return Nodes{} }
|
|
func (n *miniNode) PtrInit() *Nodes { return &immutableEmptyNodes }
|
|
func (n *miniNode) Body() Nodes { return Nodes{} }
|
|
func (n *miniNode) PtrBody() *Nodes { return &immutableEmptyNodes }
|
|
func (n *miniNode) List() Nodes { return Nodes{} }
|
|
func (n *miniNode) PtrList() *Nodes { return &immutableEmptyNodes }
|
|
func (n *miniNode) Rlist() Nodes { return Nodes{} }
|
|
func (n *miniNode) PtrRlist() *Nodes { return &immutableEmptyNodes }
|
|
func (n *miniNode) SetLeft(x Node) {
|
|
if x != nil {
|
|
panic(n.no("SetLeft"))
|
|
}
|
|
}
|
|
func (n *miniNode) SetRight(x Node) {
|
|
if x != nil {
|
|
panic(n.no("SetRight"))
|
|
}
|
|
}
|
|
func (n *miniNode) SetInit(x Nodes) {
|
|
if x != (Nodes{}) {
|
|
panic(n.no("SetInit"))
|
|
}
|
|
}
|
|
func (n *miniNode) SetBody(x Nodes) {
|
|
if x != (Nodes{}) {
|
|
panic(n.no("SetBody"))
|
|
}
|
|
}
|
|
func (n *miniNode) SetList(x Nodes) {
|
|
if x != (Nodes{}) {
|
|
panic(n.no("SetList"))
|
|
}
|
|
}
|
|
func (n *miniNode) SetRlist(x Nodes) {
|
|
if x != (Nodes{}) {
|
|
panic(n.no("SetRlist"))
|
|
}
|
|
}
|
|
|
|
// Additional functionality unavailable.
|
|
|
|
func (n *miniNode) no(name string) string { return "cannot " + name + " on " + n.op.String() }
|
|
|
|
func (n *miniNode) SetOp(Op) { panic(n.no("SetOp")) }
|
|
func (n *miniNode) SubOp() Op { panic(n.no("SubOp")) }
|
|
func (n *miniNode) SetSubOp(Op) { panic(n.no("SetSubOp")) }
|
|
func (n *miniNode) Type() *types.Type { return nil }
|
|
func (n *miniNode) SetType(*types.Type) { panic(n.no("SetType")) }
|
|
func (n *miniNode) Func() *Func { return nil }
|
|
func (n *miniNode) Name() *Name { return nil }
|
|
func (n *miniNode) Sym() *types.Sym { return nil }
|
|
func (n *miniNode) SetSym(*types.Sym) { panic(n.no("SetSym")) }
|
|
func (n *miniNode) Offset() int64 { return types.BADWIDTH }
|
|
func (n *miniNode) SetOffset(x int64) { panic(n.no("SetOffset")) }
|
|
func (n *miniNode) Class() Class { return Pxxx }
|
|
func (n *miniNode) SetClass(Class) { panic(n.no("SetClass")) }
|
|
func (n *miniNode) Likely() bool { panic(n.no("Likely")) }
|
|
func (n *miniNode) SetLikely(bool) { panic(n.no("SetLikely")) }
|
|
func (n *miniNode) SliceBounds() (low, high, max Node) {
|
|
panic(n.no("SliceBounds"))
|
|
}
|
|
func (n *miniNode) SetSliceBounds(low, high, max Node) {
|
|
panic(n.no("SetSliceBounds"))
|
|
}
|
|
func (n *miniNode) Iota() int64 { panic(n.no("Iota")) }
|
|
func (n *miniNode) SetIota(int64) { panic(n.no("SetIota")) }
|
|
func (n *miniNode) Colas() bool { return false }
|
|
func (n *miniNode) SetColas(bool) { panic(n.no("SetColas")) }
|
|
func (n *miniNode) NoInline() bool { panic(n.no("NoInline")) }
|
|
func (n *miniNode) SetNoInline(bool) { panic(n.no("SetNoInline")) }
|
|
func (n *miniNode) Transient() bool { panic(n.no("Transient")) }
|
|
func (n *miniNode) SetTransient(bool) { panic(n.no("SetTransient")) }
|
|
func (n *miniNode) Implicit() bool { return false }
|
|
func (n *miniNode) SetImplicit(bool) { panic(n.no("SetImplicit")) }
|
|
func (n *miniNode) IsDDD() bool { return false }
|
|
func (n *miniNode) SetIsDDD(bool) { panic(n.no("SetIsDDD")) }
|
|
func (n *miniNode) Embedded() bool { return false }
|
|
func (n *miniNode) SetEmbedded(bool) { panic(n.no("SetEmbedded")) }
|
|
func (n *miniNode) IndexMapLValue() bool { panic(n.no("IndexMapLValue")) }
|
|
func (n *miniNode) SetIndexMapLValue(bool) { panic(n.no("SetIndexMapLValue")) }
|
|
func (n *miniNode) ResetAux() { panic(n.no("ResetAux")) }
|
|
func (n *miniNode) HasBreak() bool { panic(n.no("HasBreak")) }
|
|
func (n *miniNode) SetHasBreak(bool) { panic(n.no("SetHasBreak")) }
|
|
func (n *miniNode) Val() constant.Value { panic(n.no("Val")) }
|
|
func (n *miniNode) SetVal(v constant.Value) { panic(n.no("SetVal")) }
|
|
func (n *miniNode) Int64Val() int64 { panic(n.no("Int64Val")) }
|
|
func (n *miniNode) Uint64Val() uint64 { panic(n.no("Uint64Val")) }
|
|
func (n *miniNode) CanInt64() bool { panic(n.no("CanInt64")) }
|
|
func (n *miniNode) BoolVal() bool { panic(n.no("BoolVal")) }
|
|
func (n *miniNode) StringVal() string { panic(n.no("StringVal")) }
|
|
func (n *miniNode) HasCall() bool { return false }
|
|
func (n *miniNode) SetHasCall(bool) { panic(n.no("SetHasCall")) }
|
|
func (n *miniNode) NonNil() bool { return false }
|
|
func (n *miniNode) MarkNonNil() { panic(n.no("MarkNonNil")) }
|
|
func (n *miniNode) Bounded() bool { return false }
|
|
func (n *miniNode) SetBounded(bool) { panic(n.no("SetBounded")) }
|
|
func (n *miniNode) Opt() interface{} { return nil }
|
|
func (n *miniNode) SetOpt(interface{}) { panic(n.no("SetOpt")) }
|
|
func (n *miniNode) MarkReadonly() { panic(n.no("MarkReadonly")) }
|
|
func (n *miniNode) TChanDir() types.ChanDir { panic(n.no("TChanDir")) }
|
|
func (n *miniNode) SetTChanDir(types.ChanDir) { panic(n.no("SetTChanDir")) }
|