prog: remove Dir from Type

Having Dir is Type is handy, but forces us to duplicate lots of types.
E.g. if a struct is referenced as both in and out, then we need to
have 2 copies and 2 copies of structs/types it includes.
If also prevents us from having the struct type as struct identity
(because we can have up to 3 of them).

Revert to the old way we used to do it: propagate Dir as we walk
syscall arguments. This moves lots of dir passing from pkg/compiler
to prog package.
Now Arg contains the dir, so once we build the tree, we can use dirs
as before.

Reduces size of sys/linux/gen/amd64.go from 6058336 to 5661150 (-6.6%).

Update #1580

6 files changed, 66 insertions, 64 deletions

diff --git a/sys/linux/init.go b/sys/linux/init.go
index c816bbd28..9a6eaf62e 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -50,7 +50,7 @@ func InitTarget(target *prog.Target) {
 
 	target.MakeDataMmap = targets.MakePosixMmap(target, true, true)
 	target.Neutralize = arch.neutralize
-	target.SpecialTypes = map[string]func(g *prog.Gen, typ prog.Type, old prog.Arg) (
+	target.SpecialTypes = map[string]func(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 		prog.Arg, []*prog.Call){
 		"timespec":                  arch.generateTimespec,
 		"timeval":                   arch.generateTimespec,
@@ -276,7 +276,8 @@ func (arch *arch) neutralizeIoctl(c *prog.Call) {
 	}
 }
 
-func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, old prog.Arg) (arg prog.Arg, calls []*prog.Call) {
+func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, dir prog.Dir, old prog.Arg) (
+	arg prog.Arg, calls []*prog.Call) {
 	typ := typ0.(*prog.StructType)
 	// We need to generate timespec/timeval that are either
 	// (1) definitely in the past, or
@@ -293,9 +294,9 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, old prog.Arg) (a
 	switch {
 	case g.NOutOf(1, 4):
 		// Now for relative, past for absolute.
-		arg = prog.MakeGroupArg(typ, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], nil, 0),
-			prog.MakeResultArg(typ.Fields[1], nil, 0),
+		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
+			prog.MakeResultArg(typ.Fields[0], dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[1], dir, nil, 0),
 		})
 	case g.NOutOf(1, 3):
 		// Few ms ahead for relative, past for absolute
@@ -306,38 +307,38 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, old prog.Arg) (a
 		if usec {
 			nsec /= 1e3
 		}
-		arg = prog.MakeGroupArg(typ, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], nil, 0),
-			prog.MakeResultArg(typ.Fields[1], nil, nsec),
+		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
+			prog.MakeResultArg(typ.Fields[0], dir, nil, 0),
+			prog.MakeResultArg(typ.Fields[1], dir, nil, nsec),
 		})
 	case g.NOutOf(1, 2):
 		// Unreachable fututre for both relative and absolute
-		arg = prog.MakeGroupArg(typ, []prog.Arg{
-			prog.MakeResultArg(typ.Fields[0], nil, 2e9),
-			prog.MakeResultArg(typ.Fields[1], nil, 0),
+		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
+			prog.MakeResultArg(typ.Fields[0], dir, nil, 2e9),
+			prog.MakeResultArg(typ.Fields[1], dir, nil, 0),
 		})
 	default:
 		// Few ms ahead for absolute.
 		meta := arch.clockGettimeSyscall
 		ptrArgType := meta.Args[1].(*prog.PtrType)
 		argType := ptrArgType.Type.(*prog.StructType)
-		tp := prog.MakeGroupArg(argType, []prog.Arg{
-			prog.MakeResultArg(argType.Fields[0], nil, 0),
-			prog.MakeResultArg(argType.Fields[1], nil, 0),
+		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),
 		})
 		var tpaddr prog.Arg
-		tpaddr, calls = g.Alloc(ptrArgType, tp)
+		tpaddr, calls = g.Alloc(ptrArgType, prog.DirIn, tp)
 		gettime := &prog.Call{
 			Meta: meta,
 			Args: []prog.Arg{
-				prog.MakeConstArg(meta.Args[0], arch.CLOCK_REALTIME),
+				prog.MakeConstArg(meta.Args[0], prog.DirIn, arch.CLOCK_REALTIME),
 				tpaddr,
 			},
 			Ret: prog.MakeReturnArg(meta.Ret),
 		}
 		calls = append(calls, gettime)
-		sec := prog.MakeResultArg(typ.Fields[0], tp.Inner[0].(*prog.ResultArg), 0)
-		nsec := prog.MakeResultArg(typ.Fields[1], tp.Inner[1].(*prog.ResultArg), 0)
+		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)
 		msec := timeout1
 		if g.NOutOf(1, 2) {
 			msec = timeout2
@@ -348,7 +349,7 @@ func (arch *arch) generateTimespec(g *prog.Gen, typ0 prog.Type, old prog.Arg) (a
 		} else {
 			nsec.OpAdd = msec * 1e6
 		}
-		arg = prog.MakeGroupArg(typ, []prog.Arg{sec, nsec})
+		arg = prog.MakeGroupArg(typ, dir, []prog.Arg{sec, nsec})
 	}
 	return
 }
diff --git a/sys/linux/init_alg.go b/sys/linux/init_alg.go
index 74734907a..0e6e13fac 100644
--- a/sys/linux/init_alg.go
+++ b/sys/linux/init_alg.go
@@ -9,58 +9,59 @@ import (
 	"github.com/google/syzkaller/prog"
 )
 
-func (arch *arch) generateSockaddrAlg(g *prog.Gen, typ0 prog.Type, old prog.Arg) (
+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], &calls)
+	family := g.GenerateArg(typ.Fields[0], 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], 0)
-	mask := prog.MakeConstArg(typ.Fields[3], 0)
+	feat := prog.MakeConstArg(typ.Fields[2], dir, 0)
+	mask := prog.MakeConstArg(typ.Fields[3], dir, 0)
 	if g.NOutOf(1, 1000) {
-		feat = g.GenerateArg(typ.Fields[2], &calls).(*prog.ConstArg)
-		mask = g.GenerateArg(typ.Fields[3], &calls).(*prog.ConstArg)
+		feat = g.GenerateArg(typ.Fields[2], dir, &calls).(*prog.ConstArg)
+		mask = g.GenerateArg(typ.Fields[3], 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())
-	arg = prog.MakeGroupArg(typ, []prog.Arg{
+	arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
 		family,
-		prog.MakeDataArg(typ.Fields[1], algTypeData),
+		prog.MakeDataArg(typ.Fields[1], dir, algTypeData),
 		feat,
 		mask,
-		prog.MakeDataArg(typ.Fields[4], algNameData),
+		prog.MakeDataArg(typ.Fields[4], dir, algNameData),
 	})
 	return
 }
 
-func (arch *arch) generateAlgName(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateAlgName(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return generateAlgNameStruct(g, typ, allTypes[g.Rand().Intn(len(allTypes))].typ)
+	return generateAlgNameStruct(g, typ, dir, allTypes[g.Rand().Intn(len(allTypes))].typ)
 }
 
-func (arch *arch) generateAlgAeadName(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateAlgAeadName(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return generateAlgNameStruct(g, typ, ALG_AEAD)
+	return generateAlgNameStruct(g, typ, dir, ALG_AEAD)
 }
 
-func (arch *arch) generateAlgHashName(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateAlgHashName(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return generateAlgNameStruct(g, typ, ALG_HASH)
+	return generateAlgNameStruct(g, typ, dir, ALG_HASH)
 }
 
-func (arch *arch) generateAlgSkcipherhName(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateAlgSkcipherhName(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return generateAlgNameStruct(g, typ, ALG_SKCIPHER)
+	return generateAlgNameStruct(g, typ, dir, ALG_SKCIPHER)
 }
 
-func generateAlgNameStruct(g *prog.Gen, typ0 prog.Type, algTyp int) (arg prog.Arg, calls []*prog.Call) {
+func generateAlgNameStruct(g *prog.Gen, typ0 prog.Type, dir prog.Dir, algTyp int) (
+	arg prog.Arg, calls []*prog.Call) {
 	typ := typ0.(*prog.StructType)
 	algName := generateAlg(g.Rand(), algTyp)
 	algNameData := fixedSizeData(algName, typ.Fields[0].Size())
-	arg = prog.MakeGroupArg(typ, []prog.Arg{
-		prog.MakeDataArg(typ.Fields[0], algNameData),
+	arg = prog.MakeGroupArg(typ, dir, []prog.Arg{
+		prog.MakeDataArg(typ.Fields[0], dir, algNameData),
 	})
 	return
 }
diff --git a/sys/linux/init_iptables.go b/sys/linux/init_iptables.go
index a1adf3fb0..7e96662fb 100644
--- a/sys/linux/init_iptables.go
+++ b/sys/linux/init_iptables.go
@@ -9,17 +9,17 @@ import (
 	"github.com/google/syzkaller/prog"
 )
 
-func (arch *arch) generateIptables(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateIptables(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return arch.generateNetfilterTable(g, typ, old, true, 5)
+	return arch.generateNetfilterTable(g, typ, dir, old, true, 5)
 }
 
-func (arch *arch) generateArptables(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateArptables(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
-	return arch.generateNetfilterTable(g, typ, old, false, 3)
+	return arch.generateNetfilterTable(g, typ, dir, old, false, 3)
 }
 
-func (arch *arch) generateNetfilterTable(g *prog.Gen, typ prog.Type, old prog.Arg,
+func (arch *arch) generateNetfilterTable(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg,
 	hasUnion bool, hookCount int) (arg prog.Arg, calls []*prog.Call) {
 	const (
 		hookStart     = 4
@@ -27,7 +27,7 @@ func (arch *arch) generateNetfilterTable(g *prog.Gen, typ prog.Type, old prog.Ar
 		unused        = uint64(^uint32(0))
 	)
 	if old == nil {
-		arg = g.GenerateSpecialArg(typ, &calls)
+		arg = g.GenerateSpecialArg(typ, dir, &calls)
 	} else {
 		// TODO(dvyukov): try to restore original hook order after mutation
 		// instead of assigning brand new offsets.
@@ -106,10 +106,10 @@ func (arch *arch) generateNetfilterTable(g *prog.Gen, typ prog.Type, old prog.Ar
 	return
 }
 
-func (arch *arch) generateEbtables(g *prog.Gen, typ prog.Type, old prog.Arg) (
+func (arch *arch) generateEbtables(g *prog.Gen, typ prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
 	if old == nil {
-		arg = g.GenerateSpecialArg(typ, &calls)
+		arg = g.GenerateSpecialArg(typ, dir, &calls)
 	} else {
 		// TODO(dvyukov): try to restore original hook order after mutation
 		// instead of assigning brand new offsets.
diff --git a/sys/linux/init_vusb.go b/sys/linux/init_vusb.go
index 7a61b0942..fc847be41 100644
--- a/sys/linux/init_vusb.go
+++ b/sys/linux/init_vusb.go
@@ -50,11 +50,11 @@ type HidDeviceID struct {
 	Product uint32
 }
 
-func (arch *arch) generateUsbDeviceDescriptor(g *prog.Gen, typ0 prog.Type, old prog.Arg) (
+func (arch *arch) generateUsbDeviceDescriptor(g *prog.Gen, typ0 prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
 
 	if old == nil {
-		arg = g.GenerateSpecialArg(typ0, &calls)
+		arg = g.GenerateSpecialArg(typ0, dir, &calls)
 	} else {
 		arg = old
 		calls = g.MutateArg(arg)
@@ -140,11 +140,11 @@ func randUsbDeviceID(g *prog.Gen) UsbDeviceID {
 	return id
 }
 
-func (arch *arch) generateUsbHidDeviceDescriptor(g *prog.Gen, typ0 prog.Type, old prog.Arg) (
+func (arch *arch) generateUsbHidDeviceDescriptor(g *prog.Gen, typ0 prog.Type, dir prog.Dir, old prog.Arg) (
 	arg prog.Arg, calls []*prog.Call) {
 
 	if old == nil {
-		arg = g.GenerateSpecialArg(typ0, &calls)
+		arg = g.GenerateSpecialArg(typ0, dir, &calls)
 	} else {
 		arg = old
 		calls = g.MutateArg(arg)
diff --git a/sys/targets/common.go b/sys/targets/common.go
index beac7004d..908be3ff7 100644
--- a/sys/targets/common.go
+++ b/sys/targets/common.go
@@ -22,19 +22,19 @@ func MakePosixMmap(target *prog.Target, exec, contain bool) func() []*prog.Call
 	const invalidFD = ^uint64(0)
 	makeMmap := func(addr, size, prot uint64) *prog.Call {
 		args := []prog.Arg{
-			prog.MakeVmaPointerArg(meta.Args[0], addr, size),
-			prog.MakeConstArg(meta.Args[1], size),
-			prog.MakeConstArg(meta.Args[2], prot),
-			prog.MakeConstArg(meta.Args[3], flags),
-			prog.MakeResultArg(meta.Args[4], nil, invalidFD),
+			prog.MakeVmaPointerArg(meta.Args[0], prog.DirIn, addr, size),
+			prog.MakeConstArg(meta.Args[1], prog.DirIn, size),
+			prog.MakeConstArg(meta.Args[2], prog.DirIn, prot),
+			prog.MakeConstArg(meta.Args[3], prog.DirIn, flags),
+			prog.MakeResultArg(meta.Args[4], prog.DirIn, nil, invalidFD),
 		}
 		i := len(args)
 		// Some targets have a padding argument between fd and offset.
 		if len(meta.Args) > 6 {
-			args = append(args, prog.MakeConstArg(meta.Args[i], 0))
+			args = append(args, prog.MakeConstArg(meta.Args[i], prog.DirIn, 0))
 			i++
 		}
-		args = append(args, prog.MakeConstArg(meta.Args[i], 0))
+		args = append(args, prog.MakeConstArg(meta.Args[i], prog.DirIn, 0))
 		return &prog.Call{
 			Meta: meta,
 			Args: args,
@@ -61,8 +61,8 @@ func MakeSyzMmap(target *prog.Target) func() []*prog.Call {
 			{
 				Meta: meta,
 				Args: []prog.Arg{
-					prog.MakeVmaPointerArg(meta.Args[0], 0, size),
-					prog.MakeConstArg(meta.Args[1], size),
+					prog.MakeVmaPointerArg(meta.Args[0], prog.DirIn, 0, size),
+					prog.MakeConstArg(meta.Args[1], prog.DirIn, size),
 				},
 				Ret: prog.MakeReturnArg(meta.Ret),
 			},
diff --git a/sys/windows/init.go b/sys/windows/init.go
index 54d93777f..574123258 100644
--- a/sys/windows/init.go
+++ b/sys/windows/init.go
@@ -35,10 +35,10 @@ func (arch *arch) makeMmap() []*prog.Call {
 		{
 			Meta: meta,
 			Args: []prog.Arg{
-				prog.MakeVmaPointerArg(meta.Args[0], 0, size),
-				prog.MakeConstArg(meta.Args[1], size),
-				prog.MakeConstArg(meta.Args[2], arch.MEM_COMMIT|arch.MEM_RESERVE),
-				prog.MakeConstArg(meta.Args[3], arch.PAGE_EXECUTE_READWRITE),
+				prog.MakeVmaPointerArg(meta.Args[0], prog.DirIn, 0, size),
+				prog.MakeConstArg(meta.Args[1], prog.DirIn, size),
+				prog.MakeConstArg(meta.Args[2], prog.DirIn, arch.MEM_COMMIT|arch.MEM_RESERVE),
+				prog.MakeConstArg(meta.Args[3], prog.DirIn, arch.PAGE_EXECUTE_READWRITE),
 			},
 			Ret: prog.MakeReturnArg(meta.Ret),
 		},