mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
cmd/compile: factor out Pkg, Sym, and Type into package types
- created new package cmd/compile/internal/types - moved Pkg, Sym, Type to new package - to break cycles, for now we need the (ugly) types/utils.go file which contains a handful of functions that must be installed early by the gc frontend - to break cycles, for now we need two functions to convert between *gc.Node and *types.Node (the latter is a dummy type) - adjusted the gc's code to use the new package and the conversion functions as needed - made several Pkg, Sym, and Type methods functions as needed - renamed constructors typ, typPtr, typArray, etc. to types.New, types.NewPtr, types.NewArray, etc. Passes toolstash-check -all. Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72 Reviewed-on: https://go-review.googlesource.com/39855 Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Robert Griesemer
parent
19bd145d07
commit
f68f292820
48 changed files with 2433 additions and 2005 deletions
|
|
@ -5,6 +5,7 @@
|
|||
package gc
|
||||
|
||||
import (
|
||||
"cmd/compile/internal/types"
|
||||
"cmd/internal/src"
|
||||
"fmt"
|
||||
)
|
||||
|
|
@ -59,7 +60,7 @@ func order(fn *Node) {
|
|||
// Ordertemp allocates a new temporary with the given type,
|
||||
// pushes it onto the temp stack, and returns it.
|
||||
// If clear is true, ordertemp emits code to zero the temporary.
|
||||
func ordertemp(t *Type, order *Order, clear bool) *Node {
|
||||
func ordertemp(t *types.Type, order *Order, clear bool) *Node {
|
||||
var_ := temp(t)
|
||||
if clear {
|
||||
a := nod(OAS, var_, nil)
|
||||
|
|
@ -83,7 +84,7 @@ func ordertemp(t *Type, order *Order, clear bool) *Node {
|
|||
// (The other candidate would be map access, but map access
|
||||
// returns a pointer to the result data instead of taking a pointer
|
||||
// to be filled in.)
|
||||
func ordercopyexpr(n *Node, t *Type, order *Order, clear int) *Node {
|
||||
func ordercopyexpr(n *Node, t *types.Type, order *Order, clear int) *Node {
|
||||
var_ := ordertemp(t, order, clear != 0)
|
||||
a := nod(OAS, var_, n)
|
||||
a = typecheck(a, Etop)
|
||||
|
|
@ -208,7 +209,7 @@ func orderaddrtemp(n *Node, order *Order) *Node {
|
|||
|
||||
// ordermapkeytemp prepares n to be a key in a map runtime call and returns n.
|
||||
// It should only be used for map runtime calls which have *_fast* versions.
|
||||
func ordermapkeytemp(t *Type, n *Node, order *Order) *Node {
|
||||
func ordermapkeytemp(t *types.Type, n *Node, order *Order) *Node {
|
||||
// Most map calls need to take the address of the key.
|
||||
// Exception: map*_fast* calls. See golang.org/issue/19015.
|
||||
if mapfast(t) == mapslow {
|
||||
|
|
@ -595,8 +596,8 @@ func orderstmt(n *Node, order *Order) {
|
|||
orderexprlist(n.List, order)
|
||||
n.Rlist.First().Left = orderexpr(n.Rlist.First().Left, order, nil) // arg to recv
|
||||
ch := n.Rlist.First().Left.Type
|
||||
tmp1 := ordertemp(ch.Elem(), order, haspointers(ch.Elem()))
|
||||
tmp2 := ordertemp(Types[TBOOL], order, false)
|
||||
tmp1 := ordertemp(ch.Elem(), order, types.Haspointers(ch.Elem()))
|
||||
tmp2 := ordertemp(types.Types[TBOOL], order, false)
|
||||
order.out = append(order.out, n)
|
||||
r := nod(OAS, n.List.First(), tmp1)
|
||||
r = typecheck(r, Etop)
|
||||
|
|
@ -745,9 +746,9 @@ func orderstmt(n *Node, order *Order) {
|
|||
// make copy.
|
||||
r := n.Right
|
||||
|
||||
if r.Type.IsString() && r.Type != Types[TSTRING] {
|
||||
if r.Type.IsString() && r.Type != types.Types[TSTRING] {
|
||||
r = nod(OCONV, r, nil)
|
||||
r.Type = Types[TSTRING]
|
||||
r.Type = types.Types[TSTRING]
|
||||
r = typecheck(r, Erv)
|
||||
}
|
||||
|
||||
|
|
@ -761,7 +762,7 @@ func orderstmt(n *Node, order *Order) {
|
|||
n.Right = ordercopyexpr(r, r.Type, order, 0)
|
||||
|
||||
// n->alloc is the temp for the iterator.
|
||||
prealloc[n] = ordertemp(Types[TUINT8], order, true)
|
||||
prealloc[n] = ordertemp(types.Types[TUINT8], order, true)
|
||||
}
|
||||
for i := range n.List.Slice() {
|
||||
n.List.SetIndex(i, orderexprinplace(n.List.Index(i), order))
|
||||
|
|
@ -862,7 +863,7 @@ func orderstmt(n *Node, order *Order) {
|
|||
n2.Ninit.Append(tmp2)
|
||||
}
|
||||
|
||||
r.Left = ordertemp(r.Right.Left.Type.Elem(), order, haspointers(r.Right.Left.Type.Elem()))
|
||||
r.Left = ordertemp(r.Right.Left.Type.Elem(), order, types.Haspointers(r.Right.Left.Type.Elem()))
|
||||
tmp2 = nod(OAS, tmp1, r.Left)
|
||||
tmp2 = typecheck(tmp2, Etop)
|
||||
n2.Ninit.Append(tmp2)
|
||||
|
|
@ -879,7 +880,7 @@ func orderstmt(n *Node, order *Order) {
|
|||
n2.Ninit.Append(tmp2)
|
||||
}
|
||||
|
||||
r.List.Set1(ordertemp(Types[TBOOL], order, false))
|
||||
r.List.Set1(ordertemp(types.Types[TBOOL], order, false))
|
||||
tmp2 = okas(tmp1, r.List.First())
|
||||
tmp2 = typecheck(tmp2, Etop)
|
||||
n2.Ninit.Append(tmp2)
|
||||
|
|
@ -1012,7 +1013,7 @@ func orderexpr(n *Node, order *Order, lhs *Node) *Node {
|
|||
orderexprlist(n.List, order)
|
||||
|
||||
if n.List.Len() > 5 {
|
||||
t := typArray(Types[TSTRING], int64(n.List.Len()))
|
||||
t := types.NewArray(types.Types[TSTRING], int64(n.List.Len()))
|
||||
prealloc[n] = ordertemp(t, order, false)
|
||||
}
|
||||
|
||||
|
|
@ -1165,7 +1166,7 @@ func orderexpr(n *Node, order *Order, lhs *Node) *Node {
|
|||
|
||||
case OCLOSURE:
|
||||
if n.Noescape() && n.Func.Cvars.Len() > 0 {
|
||||
prealloc[n] = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
|
||||
prealloc[n] = ordertemp(types.Types[TUINT8], order, false) // walk will fill in correct type
|
||||
}
|
||||
|
||||
case OARRAYLIT, OSLICELIT, OCALLPART:
|
||||
|
|
@ -1174,7 +1175,7 @@ func orderexpr(n *Node, order *Order, lhs *Node) *Node {
|
|||
orderexprlist(n.List, order)
|
||||
orderexprlist(n.Rlist, order)
|
||||
if n.Noescape() {
|
||||
prealloc[n] = ordertemp(Types[TUINT8], order, false) // walk will fill in correct type
|
||||
prealloc[n] = ordertemp(types.Types[TUINT8], order, false) // walk will fill in correct type
|
||||
}
|
||||
|
||||
case ODDDARG:
|
||||
|
|
@ -1237,7 +1238,7 @@ func orderas2(n *Node, order *Order) {
|
|||
left := []*Node{}
|
||||
for _, l := range n.List.Slice() {
|
||||
if !isblank(l) {
|
||||
tmp := ordertemp(l.Type, order, haspointers(l.Type))
|
||||
tmp := ordertemp(l.Type, order, types.Haspointers(l.Type))
|
||||
tmplist = append(tmplist, tmp)
|
||||
left = append(left, l)
|
||||
}
|
||||
|
|
@ -1266,11 +1267,11 @@ func orderokas2(n *Node, order *Order) {
|
|||
var tmp1, tmp2 *Node
|
||||
if !isblank(n.List.First()) {
|
||||
typ := n.Rlist.First().Type
|
||||
tmp1 = ordertemp(typ, order, haspointers(typ))
|
||||
tmp1 = ordertemp(typ, order, types.Haspointers(typ))
|
||||
}
|
||||
|
||||
if !isblank(n.List.Second()) {
|
||||
tmp2 = ordertemp(Types[TBOOL], order, false)
|
||||
tmp2 = ordertemp(types.Types[TBOOL], order, false)
|
||||
}
|
||||
|
||||
order.out = append(order.out, n)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue