cmd/compile: move haspointers to type.go

100% code movement.

Change-Id: Idb51c61b7363229258a3b48045e901bea68c7a85
Reviewed-on: https://go-review.googlesource.com/38911
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 336c275ede86a4471f48ea6412c38727f67bf650..6ce148b854878fda3c818d79c08a508354fb2006 100644 (file)
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -718,49 +718,6 @@ var kinds = []int{
        TUNSAFEPTR:  obj.KindUnsafePointer,
 }
 
-func haspointers(t *Type) bool {
-       switch t.Etype {
-       case TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64,
-               TUINT64, TUINTPTR, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TBOOL:
-               return false
-
-       case TSLICE:
-               return true
-
-       case TARRAY:
-               at := t.Extra.(*ArrayType)
-               if at.Haspointers != 0 {
-                       return at.Haspointers-1 != 0
-               }
-
-               ret := false
-               if t.NumElem() != 0 { // non-empty array
-                       ret = haspointers(t.Elem())
-               }
-
-               at.Haspointers = 1 + uint8(obj.Bool2int(ret))
-               return ret
-
-       case TSTRUCT:
-               st := t.StructType()
-               if st.Haspointers != 0 {
-                       return st.Haspointers-1 != 0
-               }
-
-               ret := false
-               for _, t1 := range t.Fields().Slice() {
-                       if haspointers(t1.Type) {
-                               ret = true
-                               break
-                       }
-               }
-               st.Haspointers = 1 + uint8(obj.Bool2int(ret))
-               return ret
-       }
-
-       return true
-}
-
 // typeptrdata returns the length in bytes of the prefix of t
 // containing pointer data. Anything after this offset is scalar data.
 func typeptrdata(t *Type) int64 {

diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go
index 74285e5d3bf4f7ade5eac7765240ac1903f10009..75f98ee7f07428df75d46d2b5a7dcd608a050a6a 100644 (file)
--- a/src/cmd/compile/internal/gc/type.go
+++ b/src/cmd/compile/internal/gc/type.go
@@ -1309,6 +1309,49 @@ func (t *Type) IsUntyped() bool {
        return false
 }
 
+func haspointers(t *Type) bool {
+       switch t.Etype {
+       case TINT, TUINT, TINT8, TUINT8, TINT16, TUINT16, TINT32, TUINT32, TINT64,
+               TUINT64, TUINTPTR, TFLOAT32, TFLOAT64, TCOMPLEX64, TCOMPLEX128, TBOOL:
+               return false
+
+       case TSLICE:
+               return true
+
+       case TARRAY:
+               at := t.Extra.(*ArrayType)
+               if at.Haspointers != 0 {
+                       return at.Haspointers-1 != 0
+               }
+
+               ret := false
+               if t.NumElem() != 0 { // non-empty array
+                       ret = haspointers(t.Elem())
+               }
+
+               at.Haspointers = 1 + uint8(obj.Bool2int(ret))
+               return ret
+
+       case TSTRUCT:
+               st := t.StructType()
+               if st.Haspointers != 0 {
+                       return st.Haspointers-1 != 0
+               }
+
+               ret := false
+               for _, t1 := range t.Fields().Slice() {
+                       if haspointers(t1.Type) {
+                               ret = true
+                               break
+                       }
+               }
+               st.Haspointers = 1 + uint8(obj.Bool2int(ret))
+               return ret
+       }
+
+       return true
+}
+
 // HasPointer returns whether t contains heap pointer.
 // This is used for write barrier insertion, so we ignore
 // pointers to go:notinheap types.