cmd/compile: move Frontend field from ssa.Config to ssa.Func

Suggested by mdempsky in CL 38232.
This allows us to use the Frontend field
to associate frontend state and information
with a function.
See the following CL in the series for examples.

This is a giant CL, but it is almost entirely routine refactoring.

The ssa test API is starting to feel a bit unwieldy.
I will clean it up separately, once the dust has settled.

Passes toolstash -cmp.

Updates #15756

Change-Id: I71c573bd96ff7251935fce1391b06b1f133c3caf
Reviewed-on: https://go-review.googlesource.com/38327
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

1 files changed, 22 insertions, 22 deletions

diff --git a/src/cmd/compile/internal/ssa/decompose.go b/src/cmd/compile/internal/ssa/decompose.go
index 6f9093bbb5..a0cd5b2c41 100644
--- a/src/cmd/compile/internal/ssa/decompose.go
+++ b/src/cmd/compile/internal/ssa/decompose.go
@@ -28,15 +28,15 @@ func decomposeBuiltIn(f *Func) {
 		case t.IsInteger() && t.Size() == 8 && f.Config.IntSize == 4:
 			var elemType Type
 			if t.IsSigned() {
-				elemType = f.Config.fe.TypeInt32()
+				elemType = f.fe.TypeInt32()
 			} else {
-				elemType = f.Config.fe.TypeUInt32()
+				elemType = f.fe.TypeUInt32()
 			}
-			hiName, loName := f.Config.fe.SplitInt64(name)
+			hiName, loName := f.fe.SplitInt64(name)
 			newNames = append(newNames, hiName, loName)
 			for _, v := range f.NamedValues[name] {
 				hi := v.Block.NewValue1(v.Pos, OpInt64Hi, elemType, v)
-				lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.Config.fe.TypeUInt32(), v)
+				lo := v.Block.NewValue1(v.Pos, OpInt64Lo, f.fe.TypeUInt32(), v)
 				f.NamedValues[hiName] = append(f.NamedValues[hiName], hi)
 				f.NamedValues[loName] = append(f.NamedValues[loName], lo)
 			}
@@ -44,11 +44,11 @@ func decomposeBuiltIn(f *Func) {
 		case t.IsComplex():
 			var elemType Type
 			if t.Size() == 16 {
-				elemType = f.Config.fe.TypeFloat64()
+				elemType = f.fe.TypeFloat64()
 			} else {
-				elemType = f.Config.fe.TypeFloat32()
+				elemType = f.fe.TypeFloat32()
 			}
-			rName, iName := f.Config.fe.SplitComplex(name)
+			rName, iName := f.fe.SplitComplex(name)
 			newNames = append(newNames, rName, iName)
 			for _, v := range f.NamedValues[name] {
 				r := v.Block.NewValue1(v.Pos, OpComplexReal, elemType, v)
@@ -58,9 +58,9 @@ func decomposeBuiltIn(f *Func) {
 			}
 			delete(f.NamedValues, name)
 		case t.IsString():
-			ptrType := f.Config.fe.TypeBytePtr()
-			lenType := f.Config.fe.TypeInt()
-			ptrName, lenName := f.Config.fe.SplitString(name)
+			ptrType := f.fe.TypeBytePtr()
+			lenType := f.fe.TypeInt()
+			ptrName, lenName := f.fe.SplitString(name)
 			newNames = append(newNames, ptrName, lenName)
 			for _, v := range f.NamedValues[name] {
 				ptr := v.Block.NewValue1(v.Pos, OpStringPtr, ptrType, v)
@@ -70,9 +70,9 @@ func decomposeBuiltIn(f *Func) {
 			}
 			delete(f.NamedValues, name)
 		case t.IsSlice():
-			ptrType := f.Config.fe.TypeBytePtr()
-			lenType := f.Config.fe.TypeInt()
-			ptrName, lenName, capName := f.Config.fe.SplitSlice(name)
+			ptrType := f.fe.TypeBytePtr()
+			lenType := f.fe.TypeInt()
+			ptrName, lenName, capName := f.fe.SplitSlice(name)
 			newNames = append(newNames, ptrName, lenName, capName)
 			for _, v := range f.NamedValues[name] {
 				ptr := v.Block.NewValue1(v.Pos, OpSlicePtr, ptrType, v)
@@ -84,8 +84,8 @@ func decomposeBuiltIn(f *Func) {
 			}
 			delete(f.NamedValues, name)
 		case t.IsInterface():
-			ptrType := f.Config.fe.TypeBytePtr()
-			typeName, dataName := f.Config.fe.SplitInterface(name)
+			ptrType := f.fe.TypeBytePtr()
+			typeName, dataName := f.fe.SplitInterface(name)
 			newNames = append(newNames, typeName, dataName)
 			for _, v := range f.NamedValues[name] {
 				typ := v.Block.NewValue1(v.Pos, OpITab, ptrType, v)
@@ -129,7 +129,7 @@ func decomposeBuiltInPhi(v *Value) {
 }
 
 func decomposeStringPhi(v *Value) {
-	fe := v.Block.Func.Config.fe
+	fe := v.Block.Func.fe
 	ptrType := fe.TypeBytePtr()
 	lenType := fe.TypeInt()
 
@@ -145,7 +145,7 @@ func decomposeStringPhi(v *Value) {
 }
 
 func decomposeSlicePhi(v *Value) {
-	fe := v.Block.Func.Config.fe
+	fe := v.Block.Func.fe
 	ptrType := fe.TypeBytePtr()
 	lenType := fe.TypeInt()
 
@@ -164,7 +164,7 @@ func decomposeSlicePhi(v *Value) {
 }
 
 func decomposeInt64Phi(v *Value) {
-	fe := v.Block.Func.Config.fe
+	fe := v.Block.Func.fe
 	var partType Type
 	if v.Type.IsSigned() {
 		partType = fe.TypeInt32()
@@ -184,7 +184,7 @@ func decomposeInt64Phi(v *Value) {
 }
 
 func decomposeComplexPhi(v *Value) {
-	fe := v.Block.Func.Config.fe
+	fe := v.Block.Func.fe
 	var partType Type
 	switch z := v.Type.Size(); z {
 	case 8:
@@ -207,7 +207,7 @@ func decomposeComplexPhi(v *Value) {
 }
 
 func decomposeInterfacePhi(v *Value) {
-	ptrType := v.Block.Func.Config.fe.TypeBytePtr()
+	ptrType := v.Block.Func.fe.TypeBytePtr()
 
 	itab := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
 	data := v.Block.NewValue0(v.Pos, OpPhi, ptrType)
@@ -243,7 +243,7 @@ func decomposeUser(f *Func) {
 			n := t.NumFields()
 			fnames = fnames[:0]
 			for i := 0; i < n; i++ {
-				fnames = append(fnames, f.Config.fe.SplitStruct(name, i))
+				fnames = append(fnames, f.fe.SplitStruct(name, i))
 			}
 			for _, v := range f.NamedValues[name] {
 				for i := 0; i < n; i++ {
@@ -262,7 +262,7 @@ func decomposeUser(f *Func) {
 			if t.NumElem() != 1 {
 				f.Fatalf("array not of size 1")
 			}
-			elemName := f.Config.fe.SplitArray(name)
+			elemName := f.fe.SplitArray(name)
 			for _, v := range f.NamedValues[name] {
 				e := v.Block.NewValue1I(v.Pos, OpArraySelect, t.ElemType(), 0, v)
 				f.NamedValues[elemName] = append(f.NamedValues[elemName], e)