prog: introduce Field type

Remvoe FieldName from Type and add a separate Field type
that holds field name. Use Field for struct fields, union options
and syscalls arguments, only these really have names.

Reduces size of sys/linux/gen/amd64.go from 5665583 to 5201321 (-8.2%).
Allows to not create new type for squashed any pointer.
But main advantages will follow, e.g. removing StructDesc,
using TypeRef in Arg, etc.

Update #1580

3 files changed, 27 insertions, 26 deletions

diff --git a/sys/linux/init.go b/sys/linux/init.go
index 0ad4bfeee..65faad183 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -295,8 +295,8 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, dir prog.Dir, ol
 	case g.NOutOf(1, 4):
 		// Now for relative, past for absolute.
 		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], dir, nil, 0),
-			prog.MakeResultArg(typ.Fields[1], dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[0].Type, dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[1].Type, dir, nil, 0),
 		})
 	case g.NOutOf(1, 3):
 		// Few ms ahead for relative, past for absolute
@@ -308,37 +308,37 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, dir prog.Dir, ol
 			nsec /= 1e3
 		}
 		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], dir, nil, 0),
-			prog.MakeResultArg(typ.Fields[1], dir, nil, nsec),
+			prog.MakeResultArg(typ.Fields[0].Type, dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[1].Type, dir, nil, nsec),
 		})
 	case g.NOutOf(1, 2):
 		// Unreachable fututre for both relative and absolute
 		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], dir, nil, 2e9),
-			prog.MakeResultArg(typ.Fields[1], dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[0].Type, dir, nil, 2e9),
+			prog.MakeResultArg(typ.Fields[1].Type, dir, nil, 0),
 		})
 	default:
 		// Few ms ahead for absolute.
 		meta := arch.clockGettimeSyscall
-		ptrArgType := meta.Args[1].(*prog.PtrType)
+		ptrArgType := meta.Args[1].Type.(*prog.PtrType)
 		argType := ptrArgType.Elem.(*prog.StructType)
 		tp := prog.MakeGroupArg(argType, prog.DirOut, []prog.Arg{
-			prog.MakeResultArg(argType.Fields[0], prog.DirOut, nil, 0),
-			prog.MakeResultArg(argType.Fields[1], prog.DirOut, nil, 0),
+			prog.MakeResultArg(argType.Fields[0].Type, prog.DirOut, nil, 0),
+			prog.MakeResultArg(argType.Fields[1].Type, prog.DirOut, nil, 0),
 		})
 		var tpaddr prog.Arg
 		tpaddr, calls = g.Alloc(ptrArgType, prog.DirIn, tp)
 		gettime := &prog.Call{
 			Meta: meta,
 			Args: []prog.Arg{
-				prog.MakeConstArg(meta.Args[0], prog.DirIn, arch.CLOCK_REALTIME),
+				prog.MakeConstArg(meta.Args[0].Type, prog.DirIn, arch.CLOCK_REALTIME),
 				tpaddr,
 			},
 			Ret: prog.MakeReturnArg(meta.Ret),
 		}
 		calls = append(calls, gettime)
-		sec := prog.MakeResultArg(typ.Fields[0], dir, tp.Inner[0].(*prog.ResultArg), 0)
-		nsec := prog.MakeResultArg(typ.Fields[1], dir, tp.Inner[1].(*prog.ResultArg), 0)
+		sec := prog.MakeResultArg(typ.Fields[0].Type, dir, tp.Inner[0].(*prog.ResultArg), 0)
+		nsec := prog.MakeResultArg(typ.Fields[1].Type, dir, tp.Inner[1].(*prog.ResultArg), 0)
 		msec := timeout1
 		if g.NOutOf(1, 2) {
 			msec = timeout2
diff --git a/sys/linux/init_alg.go b/sys/linux/init_alg.go
index 0e6e13fac..dc2906ef7 100644
--- a/sys/linux/init_alg.go
+++ b/sys/linux/init_alg.go
@@ -12,25 +12,25 @@ import (
 func (arch *arch) generateSockaddrAlg(g *prog.Gen, typ0 prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
 	typ := typ0.(*prog.StructType)
-	family := g.GenerateArg(typ.Fields[0], dir, &calls)
+	family := g.GenerateArg(typ.Fields[0].Type, dir, &calls)
 	// There is very little point in generating feat/mask,
 	// because that can only fail otherwise correct bind.
-	feat := prog.MakeConstArg(typ.Fields[2], dir, 0)
-	mask := prog.MakeConstArg(typ.Fields[3], dir, 0)
+	feat := prog.MakeConstArg(typ.Fields[2].Type, dir, 0)
+	mask := prog.MakeConstArg(typ.Fields[3].Type, dir, 0)
 	if g.NOutOf(1, 1000) {
-		feat = g.GenerateArg(typ.Fields[2], dir, &calls).(*prog.ConstArg)
-		mask = g.GenerateArg(typ.Fields[3], dir, &calls).(*prog.ConstArg)
+		feat = g.GenerateArg(typ.Fields[2].Type, dir, &calls).(*prog.ConstArg)
+		mask = g.GenerateArg(typ.Fields[3].Type, dir, &calls).(*prog.ConstArg)
 	}
 	algType, algName := generateAlgName(g.Rand())
 	// Extend/truncate type/name to their fixed sizes.
-	algTypeData := fixedSizeData(algType, typ.Fields[1].Size())
-	algNameData := fixedSizeData(algName, typ.Fields[4].Size())
+	algTypeData := fixedSizeData(algType, typ.Fields[1].Type.Size())
+	algNameData := fixedSizeData(algName, typ.Fields[4].Type.Size())
 	arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
 		family,
-		prog.MakeDataArg(typ.Fields[1], dir, algTypeData),
+		prog.MakeDataArg(typ.Fields[1].Type, dir, algTypeData),
 		feat,
 		mask,
-		prog.MakeDataArg(typ.Fields[4], dir, algNameData),
+		prog.MakeDataArg(typ.Fields[4].Type, dir, algNameData),
 	})
 	return
 }
@@ -61,7 +61,7 @@ func generateAlgNameStruct(g *prog.Gen, typ0 prog.Type, dir prog.Dir, algTyp int
 	algName := generateAlg(g.Rand(), algTyp)
 	algNameData := fixedSizeData(algName, typ.Fields[0].Size())
 	arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
-		prog.MakeDataArg(typ.Fields[0], dir, algNameData),
+		prog.MakeDataArg(typ.Fields[0].Type, dir, algNameData),
 	})
 	return
 }
diff --git a/sys/linux/init_vusb.go b/sys/linux/init_vusb.go
index fc847be41..e5b67b835 100644
--- a/sys/linux/init_vusb.go
+++ b/sys/linux/init_vusb.go
@@ -171,9 +171,10 @@ func (arch *arch) generateUsbHidDeviceDescriptor(g *prog.Gen, typ0 prog.Type, di
 }
 
 func patchGroupArg(arg prog.Arg, index int, field string, value uint64) {
-	fieldArg := arg.(*prog.GroupArg).Inner[index].(*prog.ConstArg)
-	if fieldArg.Type().FieldName() != field {
-		panic(fmt.Sprintf("bad field, expected %v, found %v", field, fieldArg.Type().FieldName()))
+	a := arg.(*prog.GroupArg)
+	typ := a.Type().(*prog.StructType)
+	if field != typ.Fields[index].Name {
+		panic(fmt.Sprintf("bad field, expected %v, found %v", field, typ.Fields[index].Name))
 	}
-	fieldArg.Val = value
+	a.Inner[index].(*prog.ConstArg).Val = value
 }