mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
cmd/compile: replace all uses of ptrto by typPtr
This makes the overall naming and use of the functions to create a Type more consistent. Passes toolstash -cmp. Change-Id: Ie0d40b42cc32b5ecf5f20502675a225038ea40e4 Reviewed-on: https://go-review.googlesource.com/38354 Reviewed-by: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
This commit is contained in:
Martin Möhrmann
Josh Bleecher Snyder
parent
00f4cacb49
commit
2805d20689
15 changed files with 103 additions and 107 deletions
|
|
@ -198,7 +198,7 @@ func genhash(sym *Sym, t *Type) {
|
|||
tfn := nod(OTFUNC, nil, nil)
|
||||
fn.Func.Nname.Name.Param.Ntype = tfn
|
||||
|
||||
n := nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
|
||||
n := nod(ODCLFIELD, newname(lookup("p")), typenod(typPtr(t)))
|
||||
tfn.List.Append(n)
|
||||
np := n.Left
|
||||
n = nod(ODCLFIELD, newname(lookup("h")), typenod(Types[TUINTPTR]))
|
||||
|
|
@ -349,7 +349,7 @@ func hashfor(t *Type) *Node {
|
|||
n := newname(sym)
|
||||
n.Class = PFUNC
|
||||
tfn := nod(OTFUNC, nil, nil)
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(typPtr(t))))
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
|
||||
tfn.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
|
||||
tfn = typecheck(tfn, Etype)
|
||||
|
|
@ -376,10 +376,10 @@ func geneq(sym *Sym, t *Type) {
|
|||
tfn := nod(OTFUNC, nil, nil)
|
||||
fn.Func.Nname.Name.Param.Ntype = tfn
|
||||
|
||||
n := nod(ODCLFIELD, newname(lookup("p")), typenod(ptrto(t)))
|
||||
n := nod(ODCLFIELD, newname(lookup("p")), typenod(typPtr(t)))
|
||||
tfn.List.Append(n)
|
||||
np := n.Left
|
||||
n = nod(ODCLFIELD, newname(lookup("q")), typenod(ptrto(t)))
|
||||
n = nod(ODCLFIELD, newname(lookup("q")), typenod(typPtr(t)))
|
||||
tfn.List.Append(n)
|
||||
nq := n.Left
|
||||
n = nod(ODCLFIELD, nil, typenod(Types[TBOOL]))
|
||||
|
|
|
|||
|
|
@ -343,7 +343,7 @@ func transformclosure(xfunc *Node) {
|
|||
// and v remains PAUTOHEAP with &v heapaddr
|
||||
// (accesses will implicitly deref &v).
|
||||
addr := newname(lookupf("&%s", v.Sym.Name))
|
||||
addr.Type = ptrto(v.Type)
|
||||
addr.Type = typPtr(v.Type)
|
||||
addr.Class = PPARAM
|
||||
v.Name.Param.Heapaddr = addr
|
||||
fld.Nname = addr
|
||||
|
|
@ -382,7 +382,7 @@ func transformclosure(xfunc *Node) {
|
|||
|
||||
cv.Type = v.Type
|
||||
if !v.Name.Byval() {
|
||||
cv.Type = ptrto(v.Type)
|
||||
cv.Type = typPtr(v.Type)
|
||||
}
|
||||
offset = Rnd(offset, int64(cv.Type.Align))
|
||||
cv.Xoffset = offset
|
||||
|
|
@ -634,7 +634,7 @@ func makepartialcall(fn *Node, t0 *Type, meth *Sym) *Node {
|
|||
ptr.Name.Param.Ntype = typenod(rcvrtype)
|
||||
body = append(body, nod(OAS, ptr, cv))
|
||||
} else {
|
||||
ptr.Name.Param.Ntype = typenod(ptrto(rcvrtype))
|
||||
ptr.Name.Param.Ntype = typenod(typPtr(rcvrtype))
|
||||
body = append(body, nod(OAS, ptr, nod(OADDR, cv, nil)))
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -937,14 +937,14 @@ var thisT *Type
|
|||
|
||||
func fakethis() *Node {
|
||||
if thisT == nil {
|
||||
thisT = ptrto(typ(TSTRUCT))
|
||||
thisT = typPtr(typ(TSTRUCT))
|
||||
}
|
||||
return nod(ODCLFIELD, nil, typenod(thisT))
|
||||
}
|
||||
|
||||
func fakethisfield() *Field {
|
||||
if thisT == nil {
|
||||
thisT = ptrto(typ(TSTRUCT))
|
||||
thisT = typPtr(typ(TSTRUCT))
|
||||
}
|
||||
f := newField()
|
||||
f.Type = thisT
|
||||
|
|
@ -1046,7 +1046,7 @@ func methodsym(nsym *Sym, t0 *Type, iface int) *Sym {
|
|||
// if t0 == *t and t0 has a sym,
|
||||
// we want to see *t, not t0, in the method name.
|
||||
if t != t0 && t0.Sym != nil {
|
||||
t0 = ptrto(t)
|
||||
t0 = typPtr(t)
|
||||
}
|
||||
|
||||
suffix = ""
|
||||
|
|
|
|||
|
|
@ -1154,7 +1154,7 @@ func (e *EscState) escassign(dst, src *Node, step *EscStep) {
|
|||
a := nod(OADDR, src, nil)
|
||||
a.Pos = src.Pos
|
||||
e.nodeEscState(a).Loopdepth = e.nodeEscState(src).Loopdepth
|
||||
a.Type = ptrto(src.Type)
|
||||
a.Type = typPtr(src.Type)
|
||||
e.escflows(dst, a, e.stepAssign(nil, originalDst, src, dstwhy))
|
||||
|
||||
// Flowing multiple returns to a single dst happens when
|
||||
|
|
@ -1552,7 +1552,7 @@ func (e *EscState) esccall(call *Node, parent *Node) {
|
|||
// Introduce ODDDARG node to represent ... allocation.
|
||||
arg = nod(ODDDARG, nil, nil)
|
||||
arr := typArray(n.Type.Elem(), int64(len(args)))
|
||||
arg.Type = ptrto(arr) // make pointer so it will be tracked
|
||||
arg.Type = typPtr(arr) // make pointer so it will be tracked
|
||||
arg.Pos = call.Pos
|
||||
e.track(arg)
|
||||
call.Right = arg
|
||||
|
|
@ -1616,7 +1616,7 @@ func (e *EscState) esccall(call *Node, parent *Node) {
|
|||
arg = nod(ODDDARG, nil, nil)
|
||||
arg.Pos = call.Pos
|
||||
arr := typArray(param.Type.Elem(), int64(len(args)-i))
|
||||
arg.Type = ptrto(arr) // make pointer so it will be tracked
|
||||
arg.Type = typPtr(arr) // make pointer so it will be tracked
|
||||
e.track(arg)
|
||||
call.Right = arg
|
||||
}
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ func moveToHeap(n *Node) {
|
|||
|
||||
// Allocate a local stack variable to hold the pointer to the heap copy.
|
||||
// temp will add it to the function declaration list automatically.
|
||||
heapaddr := temp(ptrto(n.Type))
|
||||
heapaddr := temp(typPtr(n.Type))
|
||||
heapaddr.Sym = lookup("&" + n.Sym.Name)
|
||||
heapaddr.Orig.Sym = heapaddr.Sym
|
||||
|
||||
|
|
|
|||
|
|
@ -216,7 +216,7 @@ func instrumentnode(np **Node, init *Nodes, wr int, skip int) {
|
|||
instrumentnode(&n.Left, init, 0, 0)
|
||||
if n.Left.Type.IsMap() {
|
||||
n1 := nod(OCONVNOP, n.Left, nil)
|
||||
n1.Type = ptrto(Types[TUINT8])
|
||||
n1.Type = typPtr(Types[TUINT8])
|
||||
n1 = nod(OIND, n1, nil)
|
||||
n1 = typecheck(n1, Erv)
|
||||
callinstr(&n1, init, 0, skip)
|
||||
|
|
@ -568,7 +568,7 @@ func uintptraddr(n *Node) *Node {
|
|||
|
||||
func detachexpr(n *Node, init *Nodes) *Node {
|
||||
addr := nod(OADDR, n, nil)
|
||||
l := temp(ptrto(n.Type))
|
||||
l := temp(typPtr(n.Type))
|
||||
as := nod(OAS, l, addr)
|
||||
as = typecheck(as, Etop)
|
||||
as = walkexpr(as, init)
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ func walkrange(n *Node) *Node {
|
|||
init = append(init, nod(OAS, hn, nod(OLEN, ha, nil)))
|
||||
|
||||
if v2 != nil {
|
||||
hp = temp(ptrto(n.Type.Elem()))
|
||||
hp = temp(typPtr(n.Type.Elem()))
|
||||
tmp := nod(OINDEX, ha, nodintconst(0))
|
||||
tmp.SetBounded(true)
|
||||
init = append(init, nod(OAS, hp, nod(OADDR, tmp, nil)))
|
||||
|
|
|
|||
|
|
@ -111,10 +111,10 @@ func mapbucket(t *Type) *Type {
|
|||
dowidth(keytype)
|
||||
dowidth(valtype)
|
||||
if keytype.Width > MAXKEYSIZE {
|
||||
keytype = ptrto(keytype)
|
||||
keytype = typPtr(keytype)
|
||||
}
|
||||
if valtype.Width > MAXVALSIZE {
|
||||
valtype = ptrto(valtype)
|
||||
valtype = typPtr(valtype)
|
||||
}
|
||||
|
||||
field := make([]*Field, 0, 5)
|
||||
|
|
@ -158,7 +158,7 @@ func mapbucket(t *Type) *Type {
|
|||
// Arrange for the bucket to have no pointers by changing
|
||||
// the type of the overflow field to uintptr in this case.
|
||||
// See comment on hmap.overflow in ../../../../runtime/hashmap.go.
|
||||
otyp := ptrto(bucket)
|
||||
otyp := typPtr(bucket)
|
||||
if !haspointers(t.Val()) && !haspointers(t.Key()) && t.Val().Width <= MAXVALSIZE && t.Key().Width <= MAXKEYSIZE {
|
||||
otyp = Types[TUINTPTR]
|
||||
}
|
||||
|
|
@ -197,8 +197,8 @@ func hmap(t *Type) *Type {
|
|||
makefield("B", Types[TUINT8]),
|
||||
makefield("noverflow", Types[TUINT16]),
|
||||
makefield("hash0", Types[TUINT32]),
|
||||
makefield("buckets", ptrto(bucket)),
|
||||
makefield("oldbuckets", ptrto(bucket)),
|
||||
makefield("buckets", typPtr(bucket)),
|
||||
makefield("oldbuckets", typPtr(bucket)),
|
||||
makefield("nevacuate", Types[TUINTPTR]),
|
||||
makefield("overflow", Types[TUNSAFEPTR]),
|
||||
}
|
||||
|
|
@ -235,12 +235,12 @@ func hiter(t *Type) *Type {
|
|||
// }
|
||||
// must match ../../../../runtime/hashmap.go:hiter.
|
||||
var field [12]*Field
|
||||
field[0] = makefield("key", ptrto(t.Key()))
|
||||
field[1] = makefield("val", ptrto(t.Val()))
|
||||
field[2] = makefield("t", ptrto(Types[TUINT8]))
|
||||
field[3] = makefield("h", ptrto(hmap(t)))
|
||||
field[4] = makefield("buckets", ptrto(mapbucket(t)))
|
||||
field[5] = makefield("bptr", ptrto(mapbucket(t)))
|
||||
field[0] = makefield("key", typPtr(t.Key()))
|
||||
field[1] = makefield("val", typPtr(t.Val()))
|
||||
field[2] = makefield("t", typPtr(Types[TUINT8]))
|
||||
field[3] = makefield("h", typPtr(hmap(t)))
|
||||
field[4] = makefield("buckets", typPtr(mapbucket(t)))
|
||||
field[5] = makefield("bptr", typPtr(mapbucket(t)))
|
||||
field[6] = makefield("overflow0", Types[TUNSAFEPTR])
|
||||
field[7] = makefield("overflow1", Types[TUNSAFEPTR])
|
||||
field[8] = makefield("startBucket", Types[TUINTPTR])
|
||||
|
|
@ -310,7 +310,7 @@ func methods(t *Type) []*Sig {
|
|||
it := t
|
||||
|
||||
if !isdirectiface(it) {
|
||||
it = ptrto(t)
|
||||
it = typPtr(t)
|
||||
}
|
||||
|
||||
// make list of methods for t,
|
||||
|
|
@ -845,7 +845,7 @@ func dcommontype(s *Sym, ot int, t *Type) int {
|
|||
sptrWeak := true
|
||||
var sptr *Sym
|
||||
if !t.IsPtr() || t.ptrTo != nil {
|
||||
tptr := ptrto(t)
|
||||
tptr := typPtr(t)
|
||||
if t.Sym != nil || methods(tptr) != nil {
|
||||
sptrWeak = false
|
||||
}
|
||||
|
|
@ -994,7 +994,7 @@ func typenamesym(t *Type) *Sym {
|
|||
func typename(t *Type) *Node {
|
||||
s := typenamesym(t)
|
||||
n := nod(OADDR, s.Def, nil)
|
||||
n.Type = ptrto(s.Def.Type)
|
||||
n.Type = typPtr(s.Def.Type)
|
||||
n.SetAddable(true)
|
||||
n.Typecheck = 1
|
||||
return n
|
||||
|
|
@ -1016,7 +1016,7 @@ func itabname(t, itype *Type) *Node {
|
|||
}
|
||||
|
||||
n := nod(OADDR, s.Def, nil)
|
||||
n.Type = ptrto(s.Def.Type)
|
||||
n.Type = typPtr(s.Def.Type)
|
||||
n.SetAddable(true)
|
||||
n.Typecheck = 1
|
||||
return n
|
||||
|
|
@ -1473,7 +1473,7 @@ func dumptypestructs() {
|
|||
t := signatlist[i]
|
||||
dtypesym(t)
|
||||
if t.Sym != nil {
|
||||
dtypesym(ptrto(t))
|
||||
dtypesym(typPtr(t))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1550,14 +1550,14 @@ func dumptypestructs() {
|
|||
// but using runtime means fewer copies in .6 files.
|
||||
if myimportpath == "runtime" {
|
||||
for i := EType(1); i <= TBOOL; i++ {
|
||||
dtypesym(ptrto(Types[i]))
|
||||
dtypesym(typPtr(Types[i]))
|
||||
}
|
||||
dtypesym(ptrto(Types[TSTRING]))
|
||||
dtypesym(ptrto(Types[TUNSAFEPTR]))
|
||||
dtypesym(typPtr(Types[TSTRING]))
|
||||
dtypesym(typPtr(Types[TUNSAFEPTR]))
|
||||
|
||||
// emit type structs for error and func(error) string.
|
||||
// The latter is the type of an auto-generated wrapper.
|
||||
dtypesym(ptrto(errortype))
|
||||
dtypesym(typPtr(errortype))
|
||||
|
||||
dtypesym(functype(nil, []*Node{nod(ODCLFIELD, nil, typenod(errortype))}, []*Node{nod(ODCLFIELD, nil, typenod(Types[TSTRING]))}))
|
||||
|
||||
|
|
@ -1861,7 +1861,7 @@ func zeroaddr(size int64) *Node {
|
|||
s.Def = x
|
||||
}
|
||||
z := nod(OADDR, s.Def, nil)
|
||||
z.Type = ptrto(Types[TUINT8])
|
||||
z.Type = typPtr(Types[TUINT8])
|
||||
z.SetAddable(true)
|
||||
z.Typecheck = 1
|
||||
return z
|
||||
|
|
|
|||
|
|
@ -258,7 +258,7 @@ func walkselect(sel *Node) {
|
|||
r = nod(OAS, selv, nil)
|
||||
r = typecheck(r, Etop)
|
||||
init = append(init, r)
|
||||
var_ = conv(conv(nod(OADDR, selv, nil), Types[TUNSAFEPTR]), ptrto(Types[TUINT8]))
|
||||
var_ = conv(conv(nod(OADDR, selv, nil), Types[TUNSAFEPTR]), typPtr(Types[TUINT8]))
|
||||
r = mkcall("newselect", nil, nil, var_, nodintconst(selv.Type.Width), nodintconst(sel.Xoffset))
|
||||
r = typecheck(r, Etop)
|
||||
init = append(init, r)
|
||||
|
|
@ -332,11 +332,11 @@ func selecttype(size int32) *Type {
|
|||
// and then cache; and also cache Select per size.
|
||||
|
||||
scase := nod(OTSTRUCT, nil, nil)
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("elem")), typenod(ptrto(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("chan")), typenod(ptrto(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("elem")), typenod(typPtr(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("chan")), typenod(typPtr(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("pc")), typenod(Types[TUINTPTR])))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("kind")), typenod(Types[TUINT16])))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("receivedp")), typenod(ptrto(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("receivedp")), typenod(typPtr(Types[TUINT8]))))
|
||||
scase.List.Append(nod(ODCLFIELD, newname(lookup("releasetime")), typenod(Types[TUINT64])))
|
||||
scase = typecheck(scase, Etype)
|
||||
scase.Type.SetNoalg(true)
|
||||
|
|
@ -345,8 +345,8 @@ func selecttype(size int32) *Type {
|
|||
sel := nod(OTSTRUCT, nil, nil)
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("tcase")), typenod(Types[TUINT16])))
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("ncase")), typenod(Types[TUINT16])))
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("pollorder")), typenod(ptrto(Types[TUINT8]))))
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("lockorder")), typenod(ptrto(Types[TUINT8]))))
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("pollorder")), typenod(typPtr(Types[TUINT8]))))
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("lockorder")), typenod(typPtr(Types[TUINT8]))))
|
||||
arr := nod(OTARRAY, nodintconst(int64(size)), scase)
|
||||
sel.List.Append(nod(ODCLFIELD, newname(lookup("scase")), arr))
|
||||
arr = nod(OTARRAY, nodintconst(int64(size)), typenod(Types[TUINT16]))
|
||||
|
|
|
|||
|
|
@ -535,7 +535,7 @@ func staticassign(l *Node, r *Node, out *[]*Node) bool {
|
|||
*out = append(*out, nod(OAS, a, val))
|
||||
}
|
||||
ptr := nod(OADDR, a, nil)
|
||||
n.Type = ptrto(val.Type)
|
||||
n.Type = typPtr(val.Type)
|
||||
gdata(&n, ptr, Widthptr)
|
||||
}
|
||||
|
||||
|
|
@ -828,7 +828,7 @@ func slicelit(ctxt initContext, n *Node, var_ *Node, init *Nodes) {
|
|||
}
|
||||
|
||||
// make new auto *array (3 declare)
|
||||
vauto := temp(ptrto(t))
|
||||
vauto := temp(typPtr(t))
|
||||
|
||||
// set auto to point at new temp or heap (3 assign)
|
||||
var a *Node
|
||||
|
|
|
|||
|
|
@ -37,14 +37,14 @@ func initssaconfig() {
|
|||
Int: Types[TINT],
|
||||
Uintptr: Types[TUINTPTR],
|
||||
String: Types[TSTRING],
|
||||
BytePtr: ptrto(Types[TUINT8]),
|
||||
Int32Ptr: ptrto(Types[TINT32]),
|
||||
UInt32Ptr: ptrto(Types[TUINT32]),
|
||||
IntPtr: ptrto(Types[TINT]),
|
||||
UintptrPtr: ptrto(Types[TUINTPTR]),
|
||||
Float32Ptr: ptrto(Types[TFLOAT32]),
|
||||
Float64Ptr: ptrto(Types[TFLOAT64]),
|
||||
BytePtrPtr: ptrto(ptrto(Types[TUINT8])),
|
||||
BytePtr: typPtr(Types[TUINT8]),
|
||||
Int32Ptr: typPtr(Types[TINT32]),
|
||||
UInt32Ptr: typPtr(Types[TUINT32]),
|
||||
IntPtr: typPtr(Types[TINT]),
|
||||
UintptrPtr: typPtr(Types[TUINTPTR]),
|
||||
Float32Ptr: typPtr(Types[TFLOAT32]),
|
||||
Float64Ptr: typPtr(Types[TFLOAT64]),
|
||||
BytePtrPtr: typPtr(typPtr(Types[TUINT8])),
|
||||
}
|
||||
ssaConfig = ssa.NewConfig(thearch.LinkArch.Name, types, Ctxt, Debug['N'] == 0)
|
||||
if thearch.LinkArch.Name == "386" {
|
||||
|
|
@ -126,7 +126,7 @@ func buildssa(fn *Node) *ssa.Func {
|
|||
switch n.Class {
|
||||
case PPARAM, PPARAMOUT:
|
||||
aux := s.lookupSymbol(n, &ssa.ArgSymbol{Typ: n.Type, Node: n})
|
||||
s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, ptrto(n.Type), aux, s.sp)
|
||||
s.decladdrs[n] = s.entryNewValue1A(ssa.OpAddr, typPtr(n.Type), aux, s.sp)
|
||||
if n.Class == PPARAMOUT && s.canSSA(n) {
|
||||
// Save ssa-able PPARAMOUT variables so we can
|
||||
// store them back to the stack at the end of
|
||||
|
|
@ -1367,7 +1367,7 @@ func (s *state) expr(n *Node) *ssa.Value {
|
|||
// "value" of a function is the address of the function's closure
|
||||
sym := Linksym(funcsym(n.Sym))
|
||||
aux := &ssa.ExternSymbol{Typ: n.Type, Sym: sym}
|
||||
return s.entryNewValue1A(ssa.OpAddr, ptrto(n.Type), aux, s.sb)
|
||||
return s.entryNewValue1A(ssa.OpAddr, typPtr(n.Type), aux, s.sb)
|
||||
}
|
||||
if s.canSSA(n) {
|
||||
return s.variable(n, n.Type)
|
||||
|
|
@ -1875,7 +1875,7 @@ func (s *state) expr(n *Node) *ssa.Value {
|
|||
return s.addr(n.Left, n.Bounded())
|
||||
|
||||
case OINDREGSP:
|
||||
addr := s.constOffPtrSP(ptrto(n.Type), n.Xoffset)
|
||||
addr := s.constOffPtrSP(typPtr(n.Type), n.Xoffset)
|
||||
return s.newValue2(ssa.OpLoad, n.Type, addr, s.mem())
|
||||
|
||||
case OIND:
|
||||
|
|
@ -1902,7 +1902,7 @@ func (s *state) expr(n *Node) *ssa.Value {
|
|||
|
||||
case ODOTPTR:
|
||||
p := s.exprPtr(n.Left, false, n.Pos)
|
||||
p = s.newValue1I(ssa.OpOffPtr, ptrto(n.Type), n.Xoffset, p)
|
||||
p = s.newValue1I(ssa.OpOffPtr, typPtr(n.Type), n.Xoffset, p)
|
||||
return s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
|
||||
|
||||
case OINDEX:
|
||||
|
|
@ -2094,7 +2094,7 @@ func (s *state) append(n *Node, inplace bool) *ssa.Value {
|
|||
// *(ptr+len+2) = e3
|
||||
|
||||
et := n.Type.Elem()
|
||||
pt := ptrto(et)
|
||||
pt := typPtr(et)
|
||||
|
||||
// Evaluate slice
|
||||
sn := n.List.First() // the slice node is the first in the list
|
||||
|
|
@ -3083,7 +3083,7 @@ func (s *state) call(n *Node, k callKind) *ssa.Value {
|
|||
return nil
|
||||
}
|
||||
fp := res.Field(0)
|
||||
return s.constOffPtrSP(ptrto(fp.Type), fp.Offset+Ctxt.FixedFrameSize())
|
||||
return s.constOffPtrSP(typPtr(fp.Type), fp.Offset+Ctxt.FixedFrameSize())
|
||||
}
|
||||
|
||||
// etypesign returns the signed-ness of e, for integer/pointer etypes.
|
||||
|
|
@ -3122,7 +3122,7 @@ func (s *state) lookupSymbol(n *Node, sym interface{}) interface{} {
|
|||
// If bounded is true then this address does not require a nil check for its operand
|
||||
// even if that would otherwise be implied.
|
||||
func (s *state) addr(n *Node, bounded bool) *ssa.Value {
|
||||
t := ptrto(n.Type)
|
||||
t := typPtr(n.Type)
|
||||
switch n.Op {
|
||||
case ONAME:
|
||||
switch n.Class {
|
||||
|
|
@ -3183,7 +3183,7 @@ func (s *state) addr(n *Node, bounded bool) *ssa.Value {
|
|||
if !n.Bounded() {
|
||||
s.boundsCheck(i, len)
|
||||
}
|
||||
return s.newValue2(ssa.OpPtrIndex, ptrto(n.Left.Type.Elem()), a, i)
|
||||
return s.newValue2(ssa.OpPtrIndex, typPtr(n.Left.Type.Elem()), a, i)
|
||||
}
|
||||
case OIND:
|
||||
return s.exprPtr(n.Left, bounded, n.Pos)
|
||||
|
|
@ -3429,7 +3429,7 @@ func (s *state) rtcall(fn *obj.LSym, returns bool, results []*Type, args ...*ssa
|
|||
res := make([]*ssa.Value, len(results))
|
||||
for i, t := range results {
|
||||
off = Rnd(off, t.Alignment())
|
||||
ptr := s.constOffPtrSP(ptrto(t), off)
|
||||
ptr := s.constOffPtrSP(typPtr(t), off)
|
||||
res[i] = s.newValue2(ssa.OpLoad, t, ptr, s.mem())
|
||||
off += t.Size()
|
||||
}
|
||||
|
|
@ -3555,13 +3555,13 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) {
|
|||
switch {
|
||||
case t.IsSlice():
|
||||
elemtype = t.Elem()
|
||||
ptrtype = ptrto(elemtype)
|
||||
ptrtype = typPtr(elemtype)
|
||||
ptr = s.newValue1(ssa.OpSlicePtr, ptrtype, v)
|
||||
len = s.newValue1(ssa.OpSliceLen, Types[TINT], v)
|
||||
cap = s.newValue1(ssa.OpSliceCap, Types[TINT], v)
|
||||
case t.IsString():
|
||||
elemtype = Types[TUINT8]
|
||||
ptrtype = ptrto(elemtype)
|
||||
ptrtype = typPtr(elemtype)
|
||||
ptr = s.newValue1(ssa.OpStringPtr, ptrtype, v)
|
||||
len = s.newValue1(ssa.OpStringLen, Types[TINT], v)
|
||||
cap = len
|
||||
|
|
@ -3570,7 +3570,7 @@ func (s *state) slice(t *Type, v, i, j, k *ssa.Value) (p, l, c *ssa.Value) {
|
|||
s.Fatalf("bad ptr to array in slice %v\n", t)
|
||||
}
|
||||
elemtype = t.Elem().Elem()
|
||||
ptrtype = ptrto(elemtype)
|
||||
ptrtype = typPtr(elemtype)
|
||||
s.nilCheck(v)
|
||||
ptr = v
|
||||
len = s.constInt(Types[TINT], t.Elem().NumElem())
|
||||
|
|
@ -4100,7 +4100,7 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
|
|||
if direct {
|
||||
return s.newValue1(ssa.OpIData, n.Type, iface), nil
|
||||
}
|
||||
p := s.newValue1(ssa.OpIData, ptrto(n.Type), iface)
|
||||
p := s.newValue1(ssa.OpIData, typPtr(n.Type), iface)
|
||||
return s.newValue2(ssa.OpLoad, n.Type, p, s.mem()), nil
|
||||
}
|
||||
|
||||
|
|
@ -4117,11 +4117,11 @@ func (s *state) dottype(n *Node, commaok bool) (res, resok *ssa.Value) {
|
|||
if direct {
|
||||
s.vars[valVar] = s.newValue1(ssa.OpIData, n.Type, iface)
|
||||
} else {
|
||||
p := s.newValue1(ssa.OpIData, ptrto(n.Type), iface)
|
||||
p := s.newValue1(ssa.OpIData, typPtr(n.Type), iface)
|
||||
s.vars[valVar] = s.newValue2(ssa.OpLoad, n.Type, p, s.mem())
|
||||
}
|
||||
} else {
|
||||
p := s.newValue1(ssa.OpIData, ptrto(n.Type), iface)
|
||||
p := s.newValue1(ssa.OpIData, typPtr(n.Type), iface)
|
||||
store := s.newValue3I(ssa.OpMove, ssa.TypeMem, n.Type.Size(), addr, p, s.mem())
|
||||
store.Aux = n.Type
|
||||
s.vars[&memVar] = store
|
||||
|
|
@ -4712,7 +4712,7 @@ func (e *ssafn) Auto(t ssa.Type) ssa.GCNode {
|
|||
|
||||
func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
|
||||
n := name.N.(*Node)
|
||||
ptrType := ptrto(Types[TUINT8])
|
||||
ptrType := typPtr(Types[TUINT8])
|
||||
lenType := Types[TINT]
|
||||
if n.Class == PAUTO && !n.Addrtaken() {
|
||||
// Split this string up into two separate variables.
|
||||
|
|
@ -4726,7 +4726,7 @@ func (e *ssafn) SplitString(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
|
|||
|
||||
func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot) {
|
||||
n := name.N.(*Node)
|
||||
t := ptrto(Types[TUINT8])
|
||||
t := typPtr(Types[TUINT8])
|
||||
if n.Class == PAUTO && !n.Addrtaken() {
|
||||
// Split this interface up into two separate variables.
|
||||
f := ".itab"
|
||||
|
|
@ -4743,7 +4743,7 @@ func (e *ssafn) SplitInterface(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot
|
|||
|
||||
func (e *ssafn) SplitSlice(name ssa.LocalSlot) (ssa.LocalSlot, ssa.LocalSlot, ssa.LocalSlot) {
|
||||
n := name.N.(*Node)
|
||||
ptrType := ptrto(name.Type.ElemType().(*Type))
|
||||
ptrType := typPtr(name.Type.ElemType().(*Type))
|
||||
lenType := Types[TINT]
|
||||
if n.Class == PAUTO && !n.Addrtaken() {
|
||||
// Split this slice up into three separate variables.
|
||||
|
|
|
|||
|
|
@ -1112,18 +1112,6 @@ func typehash(t *Type) uint32 {
|
|||
return binary.LittleEndian.Uint32(h[:4])
|
||||
}
|
||||
|
||||
// ptrto returns the Type *t.
|
||||
// The returned struct must not be modified.
|
||||
func ptrto(t *Type) *Type {
|
||||
if Tptr == 0 {
|
||||
Fatalf("ptrto: no tptr")
|
||||
}
|
||||
if t == nil {
|
||||
Fatalf("ptrto: nil ptr")
|
||||
}
|
||||
return typPtr(t)
|
||||
}
|
||||
|
||||
func frame(context int) {
|
||||
if context != 0 {
|
||||
fmt.Printf("--- external frame ---\n")
|
||||
|
|
@ -1826,7 +1814,7 @@ func hashmem(t *Type) *Node {
|
|||
n := newname(sym)
|
||||
n.Class = PFUNC
|
||||
tfn := nod(OTFUNC, nil, nil)
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(typPtr(t))))
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
|
||||
tfn.List.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
|
||||
tfn.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TUINTPTR])))
|
||||
|
|
@ -2123,7 +2111,7 @@ func isdirectiface(t *Type) bool {
|
|||
// itabType loads the _type field from a runtime.itab struct.
|
||||
func itabType(itab *Node) *Node {
|
||||
typ := nodSym(ODOTPTR, itab, nil)
|
||||
typ.Type = ptrto(Types[TUINT8])
|
||||
typ.Type = typPtr(Types[TUINT8])
|
||||
typ.Typecheck = 1
|
||||
typ.Xoffset = int64(Widthptr) // offset of _type in runtime.itab
|
||||
typ.SetBounded(true) // guaranteed not to fault
|
||||
|
|
@ -2140,7 +2128,7 @@ func ifaceData(n *Node, t *Type) *Node {
|
|||
ptr.Typecheck = 1
|
||||
return ptr
|
||||
}
|
||||
ptr.Type = ptrto(t)
|
||||
ptr.Type = typPtr(t)
|
||||
ptr.SetBounded(true)
|
||||
ptr.Typecheck = 1
|
||||
ind := nod(OIND, ptr, nil)
|
||||
|
|
|
|||
|
|
@ -494,13 +494,21 @@ func typMap(k, v *Type) *Type {
|
|||
|
||||
// typPtr returns the pointer type pointing to t.
|
||||
func typPtr(elem *Type) *Type {
|
||||
if elem == nil {
|
||||
Fatalf("typPtr: pointer to elem Type is nil")
|
||||
}
|
||||
|
||||
if t := elem.ptrTo; t != nil {
|
||||
if t.Elem() != elem {
|
||||
Fatalf("elem mismatch")
|
||||
Fatalf("typPtr: elem mismatch")
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
if Tptr == 0 {
|
||||
Fatalf("typPtr: Tptr not intialized")
|
||||
}
|
||||
|
||||
t := typ(Tptr)
|
||||
t.Extra = PtrType{Elem: elem}
|
||||
t.Width = int64(Widthptr)
|
||||
|
|
@ -1217,7 +1225,7 @@ func (t *Type) ElemType() ssa.Type {
|
|||
return t.Elem()
|
||||
}
|
||||
func (t *Type) PtrTo() ssa.Type {
|
||||
return ptrto(t)
|
||||
return typPtr(t)
|
||||
}
|
||||
|
||||
func (t *Type) NumFields() int {
|
||||
|
|
|
|||
|
|
@ -492,7 +492,7 @@ OpSwitch:
|
|||
if l.Op == OTYPE {
|
||||
ok |= Etype
|
||||
n.Op = OTYPE
|
||||
n.Type = ptrto(l.Type)
|
||||
n.Type = typPtr(l.Type)
|
||||
n.Left = nil
|
||||
break OpSwitch
|
||||
}
|
||||
|
|
@ -823,7 +823,7 @@ OpSwitch:
|
|||
n.Type = nil
|
||||
return n
|
||||
}
|
||||
n.Type = ptrto(t)
|
||||
n.Type = typPtr(t)
|
||||
break OpSwitch
|
||||
|
||||
case OCOMPLIT:
|
||||
|
|
@ -1871,7 +1871,7 @@ OpSwitch:
|
|||
}
|
||||
|
||||
n.Left = l
|
||||
n.Type = ptrto(t)
|
||||
n.Type = typPtr(t)
|
||||
break OpSwitch
|
||||
|
||||
case OPRINT, OPRINTN:
|
||||
|
|
@ -1933,7 +1933,7 @@ OpSwitch:
|
|||
if !t.IsInterface() {
|
||||
Fatalf("OITAB of %v", t)
|
||||
}
|
||||
n.Type = ptrto(Types[TUINTPTR])
|
||||
n.Type = typPtr(Types[TUINTPTR])
|
||||
break OpSwitch
|
||||
|
||||
case OIDATA:
|
||||
|
|
@ -1954,9 +1954,9 @@ OpSwitch:
|
|||
Fatalf("OSPTR of %v", t)
|
||||
}
|
||||
if t.IsString() {
|
||||
n.Type = ptrto(Types[TUINT8])
|
||||
n.Type = typPtr(Types[TUINT8])
|
||||
} else {
|
||||
n.Type = ptrto(t.Elem())
|
||||
n.Type = typPtr(t.Elem())
|
||||
}
|
||||
break OpSwitch
|
||||
|
||||
|
|
|
|||
|
|
@ -843,7 +843,7 @@ opswitch:
|
|||
|
||||
// don't generate a = *var if a is _
|
||||
if !isblank(a) {
|
||||
var_ := temp(ptrto(t.Val()))
|
||||
var_ := temp(typPtr(t.Val()))
|
||||
var_.Typecheck = 1
|
||||
var_.SetNonNil(true) // mapaccess always returns a non-nil pointer
|
||||
n.List.SetFirst(var_)
|
||||
|
|
@ -954,7 +954,7 @@ opswitch:
|
|||
init.Append(nod(OAS, c, n.Left))
|
||||
|
||||
// Get the itab out of the interface.
|
||||
tmp := temp(ptrto(Types[TUINT8]))
|
||||
tmp := temp(typPtr(Types[TUINT8]))
|
||||
init.Append(nod(OAS, tmp, typecheck(nod(OITAB, c, nil), Erv)))
|
||||
|
||||
// Get the type out of the itab.
|
||||
|
|
@ -963,7 +963,7 @@ opswitch:
|
|||
init.Append(nif)
|
||||
|
||||
// Build the result.
|
||||
e := nod(OEFACE, tmp, ifaceData(c, ptrto(Types[TUINT8])))
|
||||
e := nod(OEFACE, tmp, ifaceData(c, typPtr(Types[TUINT8])))
|
||||
e.Type = n.Type // assign type manually, typecheck doesn't understand OEFACE.
|
||||
e.Typecheck = 1
|
||||
n = e
|
||||
|
|
@ -1203,14 +1203,14 @@ opswitch:
|
|||
}
|
||||
|
||||
if w := t.Val().Width; w <= 1024 { // 1024 must match ../../../../runtime/hashmap.go:maxZero
|
||||
n = mkcall1(mapfn(p, t), ptrto(t.Val()), init, typename(t), map_, key)
|
||||
n = mkcall1(mapfn(p, t), typPtr(t.Val()), init, typename(t), map_, key)
|
||||
} else {
|
||||
p = "mapaccess1_fat"
|
||||
z := zeroaddr(w)
|
||||
n = mkcall1(mapfn(p, t), ptrto(t.Val()), init, typename(t), map_, key, z)
|
||||
n = mkcall1(mapfn(p, t), typPtr(t.Val()), init, typename(t), map_, key, z)
|
||||
}
|
||||
}
|
||||
n.Type = ptrto(t.Val())
|
||||
n.Type = typPtr(t.Val())
|
||||
n.SetNonNil(true) // mapaccess1* and mapassign always return non-nil pointers.
|
||||
n = nod(OIND, n, nil)
|
||||
n.Type = t.Val()
|
||||
|
|
@ -1975,7 +1975,7 @@ func callnew(t *Type) *Node {
|
|||
dowidth(t)
|
||||
fn := syslook("newobject")
|
||||
fn = substArgTypes(fn, t)
|
||||
v := mkcall1(fn, ptrto(t), nil, typename(t))
|
||||
v := mkcall1(fn, typPtr(t), nil, typename(t))
|
||||
v.SetNonNil(true)
|
||||
return v
|
||||
}
|
||||
|
|
@ -3025,8 +3025,8 @@ func eqfor(t *Type, needsize *int) *Node {
|
|||
n := newname(sym)
|
||||
n.Class = PFUNC
|
||||
ntype := nod(OTFUNC, nil, nil)
|
||||
ntype.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
|
||||
ntype.List.Append(nod(ODCLFIELD, nil, typenod(ptrto(t))))
|
||||
ntype.List.Append(nod(ODCLFIELD, nil, typenod(typPtr(t))))
|
||||
ntype.List.Append(nod(ODCLFIELD, nil, typenod(typPtr(t))))
|
||||
ntype.Rlist.Append(nod(ODCLFIELD, nil, typenod(Types[TBOOL])))
|
||||
ntype = typecheck(ntype, Etype)
|
||||
n.Type = ntype.Type
|
||||
|
|
@ -3071,7 +3071,7 @@ func walkcompare(n *Node, init *Nodes) *Node {
|
|||
tab := nod(OITAB, l, nil)
|
||||
rtyp := typename(r.Type)
|
||||
if l.Type.IsEmptyInterface() {
|
||||
tab.Type = ptrto(Types[TUINT8])
|
||||
tab.Type = typPtr(Types[TUINT8])
|
||||
tab.Typecheck = 1
|
||||
eqtype = nod(eq, tab, rtyp)
|
||||
} else {
|
||||
|
|
@ -3128,13 +3128,13 @@ func walkcompare(n *Node, init *Nodes) *Node {
|
|||
}
|
||||
|
||||
// eq algs take pointers
|
||||
pl := temp(ptrto(t))
|
||||
pl := temp(typPtr(t))
|
||||
al := nod(OAS, pl, nod(OADDR, cmpl, nil))
|
||||
al.Right.Etype = 1 // addr does not escape
|
||||
al = typecheck(al, Etop)
|
||||
init.Append(al)
|
||||
|
||||
pr := temp(ptrto(t))
|
||||
pr := temp(typPtr(t))
|
||||
ar := nod(OAS, pr, nod(OADDR, cmpr, nil))
|
||||
ar.Right.Etype = 1 // addr does not escape
|
||||
ar = typecheck(ar, Etop)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue