sys/targets: add OS/Arch name consts

We use strings to identify OS/Arch.
These strings are duplicated throughout the code base massively.
golangci-lint points to possiblity of typos and duplication.
We already had to define these names in pkg/csource
and disable checking for prog package. A future change triggers
such warnings in another package.

Add OS/Arch name consts to sys/targets so that they can be used
to refer to OS/Arch. Use the consts everywhere.

63 files changed, 323 insertions, 258 deletions

diff --git a/dashboard/app/api.go b/dashboard/app/api.go
index 73a802d61..f802603d8 100644
--- a/dashboard/app/api.go
+++ b/dashboard/app/api.go
@@ -19,6 +19,7 @@ import (
 	"github.com/google/syzkaller/dashboard/dashapi"
 	"github.com/google/syzkaller/pkg/email"
 	"github.com/google/syzkaller/pkg/hash"
+	"github.com/google/syzkaller/sys/targets"
 	"golang.org/x/net/context"
 	"google.golang.org/appengine"
 	db "google.golang.org/appengine/datastore"
@@ -784,7 +785,7 @@ func saveCrash(c context.Context, ns string, req *dashapi.Crash, bugKey *db.Key,
 	} else if len(req.ReproSyz) != 0 {
 		prio += 2e12
 	}
-	if build.Arch == "amd64" {
+	if build.Arch == targets.AMD64 {
 		prio += 1e3
 	}
 	crash := &Crash{
diff --git a/dashboard/app/app_test.go b/dashboard/app/app_test.go
index 95b313306..3f80e5a16 100644
--- a/dashboard/app/app_test.go
+++ b/dashboard/app/app_test.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/dashboard/dashapi"
+	"github.com/google/syzkaller/sys/targets"
 	"google.golang.org/appengine/user"
 )
 
@@ -287,9 +288,9 @@ func testBuild(id int) *dashapi.Build {
 	return &dashapi.Build{
 		Manager:           fmt.Sprintf("manager%v", id),
 		ID:                fmt.Sprintf("build%v", id),
-		OS:                "linux",
-		Arch:              "amd64",
-		VMArch:            "amd64",
+		OS:                targets.Linux,
+		Arch:              targets.AMD64,
+		VMArch:            targets.AMD64,
 		SyzkallerCommit:   fmt.Sprintf("syzkaller_commit%v", id),
 		CompilerID:        fmt.Sprintf("compiler%v", id),
 		KernelRepo:        fmt.Sprintf("repo%v", id),
diff --git a/dashboard/app/email_test.go b/dashboard/app/email_test.go
index 2e73e61f3..e3eae3944 100644
--- a/dashboard/app/email_test.go
+++ b/dashboard/app/email_test.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/google/syzkaller/dashboard/dashapi"
 	"github.com/google/syzkaller/pkg/email"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // nolint: funlen
@@ -121,7 +122,7 @@ For more options, visit https://groups.google.com/d/optout.
 
 	// Now report syz reproducer and check updated email.
 	build2 := testBuild(10)
-	build2.Arch = "386"
+	build2.Arch = targets.I386
 	build2.KernelRepo = testConfig.Namespaces["test2"].Repos[0].URL
 	build2.KernelBranch = testConfig.Namespaces["test2"].Repos[0].Branch
 	build2.KernelCommitTitle = "a really long title, longer than 80 chars, really long-long-long-long-long-long title"
diff --git a/dashboard/app/reporting.go b/dashboard/app/reporting.go
index 54ad38cdd..35a050fcb 100644
--- a/dashboard/app/reporting.go
+++ b/dashboard/app/reporting.go
@@ -15,6 +15,7 @@ import (
 	"github.com/google/syzkaller/dashboard/dashapi"
 	"github.com/google/syzkaller/pkg/email"
 	"github.com/google/syzkaller/pkg/html"
+	"github.com/google/syzkaller/sys/targets"
 	"golang.org/x/net/context"
 	db "google.golang.org/appengine/datastore"
 	"google.golang.org/appengine/log"
@@ -1175,9 +1176,9 @@ func (a bugReportSorter) Less(i, j int) bool {
 // Currently Linux-specific.
 func kernelArch(arch string) string {
 	switch arch {
-	case "386":
+	case targets.I386:
 		return "i386"
-	case "amd64":
+	case targets.AMD64:
 		return "" // this is kinda the default, so we don't notify about it
 	default:
 		return arch
diff --git a/dashboard/app/reporting_test.go b/dashboard/app/reporting_test.go
index 1aa7a4979..7be5e023f 100644
--- a/dashboard/app/reporting_test.go
+++ b/dashboard/app/reporting_test.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/dashboard/dashapi"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestReportBug(t *testing.T) {
@@ -45,9 +46,9 @@ func TestReportBug(t *testing.T) {
 		Namespace:         "test1",
 		Config:            []byte(`{"Index":1}`),
 		ID:                rep.ID,
-		OS:                "linux",
-		Arch:              "amd64",
-		VMArch:            "amd64",
+		OS:                targets.Linux,
+		Arch:              targets.AMD64,
+		VMArch:            targets.AMD64,
 		First:             true,
 		Moderation:        true,
 		Title:             "title1",
@@ -208,9 +209,9 @@ func TestInvalidBug(t *testing.T) {
 		Namespace:         "test1",
 		Config:            []byte(`{"Index":1}`),
 		ID:                rep.ID,
-		OS:                "linux",
-		Arch:              "amd64",
-		VMArch:            "amd64",
+		OS:                targets.Linux,
+		Arch:              targets.AMD64,
+		VMArch:            targets.AMD64,
 		First:             true,
 		Moderation:        true,
 		Title:             "title1 (2)",
diff --git a/pkg/ast/parser_test.go b/pkg/ast/parser_test.go
index b5861b5a8..d3a9049bc 100644
--- a/pkg/ast/parser_test.go
+++ b/pkg/ast/parser_test.go
@@ -10,10 +10,12 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestParseAll(t *testing.T) {
-	files, err := filepath.Glob(filepath.Join("..", "..", "sys", "linux", "*.txt"))
+	files, err := filepath.Glob(filepath.Join("..", "..", "sys", targets.Linux, "*.txt"))
 	if err != nil || len(files) == 0 {
 		t.Fatalf("failed to read sys dir: %v", err)
 	}
diff --git a/pkg/bisect/bisect_test.go b/pkg/bisect/bisect_test.go
index c21548a4d..b2b7596f1 100644
--- a/pkg/bisect/bisect_test.go
+++ b/pkg/bisect/bisect_test.go
@@ -16,6 +16,7 @@ import (
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/report"
 	"github.com/google/syzkaller/pkg/vcs"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // testEnv will implement instance.BuilderTester. This allows us to
@@ -106,7 +107,7 @@ func createTestRepo(t *testing.T) string {
 }
 
 func runBisection(t *testing.T, baseDir string, test BisectionTest) (*Result, error) {
-	r, err := vcs.NewRepo("test", "64", baseDir, vcs.OptPrecious)
+	r, err := vcs.NewRepo(targets.TestOS, targets.TestArch64, baseDir, vcs.OptPrecious)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -120,8 +121,8 @@ func runBisection(t *testing.T, baseDir string, test BisectionTest) (*Result, er
 		Fix:   test.fix,
 		Trace: trace,
 		Manager: mgrconfig.Config{
-			TargetOS:     "test",
-			TargetVMArch: "64",
+			TargetOS:     targets.TestOS,
+			TargetVMArch: targets.TestArch64,
 			Type:         "qemu",
 			KernelSrc:    baseDir,
 		},
diff --git a/pkg/build/build.go b/pkg/build/build.go
index 149d8729c..9931ce0ea 100644
--- a/pkg/build/build.go
+++ b/pkg/build/build.go
@@ -16,6 +16,7 @@ import (
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/pkg/report"
 	"github.com/google/syzkaller/pkg/vcs"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // Params is input arguments for the Image function.
@@ -118,17 +119,17 @@ func getBuilder(targetOS, targetArch, vmType string) (builder, error) {
 		vms  []string
 		b    builder
 	}{
-		{"linux", "amd64", []string{"gvisor"}, gvisor{}},
-		{"linux", "amd64", []string{"gce", "qemu"}, linux{}},
-		{"linux", "ppc64le", []string{"qemu"}, linux{}},
-		{"linux", "s390x", []string{"qemu"}, linux{}},
-		{"fuchsia", "amd64", []string{"qemu"}, fuchsia{}},
-		{"fuchsia", "arm64", []string{"qemu"}, fuchsia{}},
-		{"akaros", "amd64", []string{"qemu"}, akaros{}},
-		{"openbsd", "amd64", []string{"gce", "vmm"}, openbsd{}},
-		{"netbsd", "amd64", []string{"gce", "qemu"}, netbsd{}},
-		{"freebsd", "amd64", []string{"gce", "qemu"}, freebsd{}},
-		{"test", "64", []string{"qemu"}, test{}},
+		{targets.Linux, targets.AMD64, []string{"gvisor"}, gvisor{}},
+		{targets.Linux, targets.AMD64, []string{"gce", "qemu"}, linux{}},
+		{targets.Linux, targets.PPC64LE, []string{"qemu"}, linux{}},
+		{targets.Linux, targets.S390x, []string{"qemu"}, linux{}},
+		{targets.Fuchsia, targets.AMD64, []string{"qemu"}, fuchsia{}},
+		{targets.Fuchsia, targets.ARM64, []string{"qemu"}, fuchsia{}},
+		{targets.Akaros, targets.AMD64, []string{"qemu"}, akaros{}},
+		{targets.OpenBSD, targets.AMD64, []string{"gce", "vmm"}, openbsd{}},
+		{targets.NetBSD, targets.AMD64, []string{"gce", "qemu"}, netbsd{}},
+		{targets.FreeBSD, targets.AMD64, []string{"gce", "qemu"}, freebsd{}},
+		{targets.TestOS, targets.TestArch64, []string{"qemu"}, test{}},
 	}
 	for _, s := range supported {
 		if targetOS == s.OS && targetArch == s.arch {
@@ -193,7 +194,7 @@ func extractRootCause(err error, OS, kernelSrc string) error {
 		Output:     verr.Output,
 		guiltyFile: file,
 	}
-	if file != "" && OS == "linux" {
+	if file != "" && OS == targets.Linux {
 		maintainers, err := report.GetLinuxMaintainers(kernelSrc, file)
 		if err != nil {
 			kernelErr.Output = append(kernelErr.Output, err.Error()...)
diff --git a/pkg/build/fuchsia.go b/pkg/build/fuchsia.go
index f4bb2c8b4..ea1e2dccb 100644
--- a/pkg/build/fuchsia.go
+++ b/pkg/build/fuchsia.go
@@ -33,7 +33,7 @@ func (fu fuchsia) build(params *Params) error {
 		return err
 	}
 
-	sysTarget := targets.Get("fuchsia", params.TargetArch)
+	sysTarget := targets.Get(targets.Fuchsia, params.TargetArch)
 	if sysTarget == nil {
 		return fmt.Errorf("unsupported fuchsia arch %v", params.TargetArch)
 	}
diff --git a/pkg/build/linux.go b/pkg/build/linux.go
index 36f18b84f..7566eca21 100644
--- a/pkg/build/linux.go
+++ b/pkg/build/linux.go
@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 type linux struct{}
@@ -57,9 +58,9 @@ func (linux linux) buildKernel(params *Params) error {
 	// We build only zImage/bzImage as we currently don't use modules.
 	var target string
 	switch params.TargetArch {
-	case "386", "amd64", "s390x":
+	case targets.I386, targets.AMD64, targets.S390x:
 		target = "bzImage"
-	case "ppc64le":
+	case targets.PPC64LE:
 		target = "zImage"
 	}
 
@@ -110,11 +111,11 @@ func (linux) createImage(params *Params) error {
 
 	var kernelImage string
 	switch params.TargetArch {
-	case "386", "amd64":
+	case targets.I386, targets.AMD64:
 		kernelImage = "arch/x86/boot/bzImage"
-	case "ppc64le":
+	case targets.PPC64LE:
 		kernelImage = "arch/powerpc/boot/zImage.pseries"
-	case "s390x":
+	case targets.S390x:
 		kernelImage = "arch/s390/boot/bzImage"
 	}
 	kernelImagePath := filepath.Join(params.KernelDir, filepath.FromSlash(kernelImage))
diff --git a/pkg/build/netbsd.go b/pkg/build/netbsd.go
index 43620c9cf..e0f4bcea0 100644
--- a/pkg/build/netbsd.go
+++ b/pkg/build/netbsd.go
@@ -16,6 +16,7 @@ import (
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/pkg/report"
+	"github.com/google/syzkaller/sys/targets"
 	"github.com/google/syzkaller/vm"
 )
 
@@ -104,7 +105,7 @@ func (ctx netbsd) copyKernelToDisk(targetArch, vmType, outputDir, kernel string)
 		Image:        filepath.Join(outputDir, "image"),
 		SSHKey:       filepath.Join(outputDir, "key"),
 		SSHUser:      "root",
-		TargetOS:     "netbsd",
+		TargetOS:     targets.NetBSD,
 		TargetArch:   targetArch,
 		TargetVMArch: targetArch,
 		Type:         "qemu",
diff --git a/pkg/compiler/compiler_test.go b/pkg/compiler/compiler_test.go
index e5c7987d1..9bc93a519 100644
--- a/pkg/compiler/compiler_test.go
+++ b/pkg/compiler/compiler_test.go
@@ -66,11 +66,11 @@ func TestData(t *testing.T) {
 	// E.g. if we failed to parse descriptions, we won't run type checking at all.
 	// Because of this we have one file per phase.
 	for _, name := range []string{"errors.txt", "errors2.txt", "errors3.txt", "warnings.txt", "all.txt"} {
-		for _, arch := range []string{"32_shmem", "64"} {
+		for _, arch := range []string{targets.TestArch32Shmem, targets.TestArch64} {
 			name, arch := name, arch
 			t.Run(fmt.Sprintf("%v/%v", name, arch), func(t *testing.T) {
 				t.Parallel()
-				target := targets.List["test"][arch]
+				target := targets.List[targets.TestOS][arch]
 				fileName := filepath.Join("testdata", name)
 				em := ast.NewErrorMatcher(t, fileName)
 				astDesc := ast.Parse(em.Data, name, em.ErrorHandler)
@@ -182,7 +182,7 @@ s2 {
 	if desc == nil {
 		t.Fatal("failed to parse")
 	}
-	p := Compile(desc, map[string]uint64{"SYS_foo": 1}, targets.List["test"]["64"], eh)
+	p := Compile(desc, map[string]uint64{"SYS_foo": 1}, targets.List[targets.TestOS][targets.TestArch64], eh)
 	if p == nil {
 		t.Fatal("failed to compile")
 	}
@@ -201,7 +201,7 @@ func TestCollectUnusedError(t *testing.T) {
 		t.Fatal("failed to parse")
 	}
 
-	_, err := CollectUnused(desc, targets.List["test"]["64"], nopErrorHandler)
+	_, err := CollectUnused(desc, targets.List[targets.TestOS][targets.TestArch64], nopErrorHandler)
 	if err == nil {
 		t.Fatal("CollectUnused should have failed but didn't")
 	}
@@ -252,7 +252,7 @@ func TestCollectUnused(t *testing.T) {
 			t.Fatalf("Test %d: failed to parse", i)
 		}
 
-		nodes, err := CollectUnused(desc, targets.List["test"]["64"], nil)
+		nodes, err := CollectUnused(desc, targets.List[targets.TestOS][targets.TestArch64], nil)
 		if err != nil {
 			t.Fatalf("Test %d: CollectUnused failed: %v", i, err)
 		}
diff --git a/pkg/compiler/consts_test.go b/pkg/compiler/consts_test.go
index 77a124b04..685525bc9 100644
--- a/pkg/compiler/consts_test.go
+++ b/pkg/compiler/consts_test.go
@@ -23,7 +23,7 @@ func TestExtractConsts(t *testing.T) {
 	if desc == nil {
 		t.Fatalf("failed to parse input")
 	}
-	target := targets.List["linux"]["amd64"]
+	target := targets.List[targets.Linux][targets.AMD64]
 	fileInfo := ExtractConsts(desc, target, func(pos ast.Pos, msg string) {
 		t.Fatalf("%v: %v", pos, msg)
 	})
@@ -69,7 +69,7 @@ func TestConstErrors(t *testing.T) {
 		em.DumpErrors()
 		t.Fatalf("parsing failed")
 	}
-	target := targets.List["linux"]["amd64"]
+	target := targets.List[targets.Linux][targets.AMD64]
 	ExtractConsts(desc, target, em.ErrorHandler)
 	em.Check()
 }
diff --git a/pkg/compiler/fuzz.go b/pkg/compiler/fuzz.go
index 3f888cdbd..ecb97834b 100644
--- a/pkg/compiler/fuzz.go
+++ b/pkg/compiler/fuzz.go
@@ -22,6 +22,6 @@ func Fuzz(data []byte) int {
 }
 
 var (
-	fuzzTarget = targets.Get("test", "64")
+	fuzzTarget = targets.Get(targets.TestOS, targets.TestArch64)
 	fuzzConsts = map[string]uint64{"A": 1, "B": 2, "C": 3, "SYS_A": 4, "SYS_B": 5, "SYS_C": 6}
 )
diff --git a/pkg/cover/report.go b/pkg/cover/report.go
index f61c48d11..4e6b7cd0d 100644
--- a/pkg/cover/report.go
+++ b/pkg/cover/report.go
@@ -85,7 +85,7 @@ func MakeReportGenerator(target *targets.Target, kernelObject, srcDir, buildDir
 			errc <- err
 			return
 		}
-		if target.Arch == "amd64" {
+		if target.Arch == targets.AMD64 {
 			coverPoints, err = readCoverPoints(file, tracePC)
 		} else {
 			coverPoints, err = objdump(target, kernelObject)
@@ -834,23 +834,23 @@ func parseFile(fn string) ([][]byte, error) {
 
 func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
 	switch target.Arch {
-	case "amd64":
+	case targets.AMD64:
 		return pc - 5
-	case "386":
+	case targets.I386:
 		return pc - 5
-	case "arm64":
+	case targets.ARM64:
 		return pc - 4
-	case "arm":
+	case targets.ARM:
 		// THUMB instructions are 2 or 4 bytes with low bit set.
 		// ARM instructions are always 4 bytes.
 		return (pc - 3) & ^uint64(1)
-	case "ppc64le":
+	case targets.PPC64LE:
 		return pc - 4
-	case "mips64le":
+	case targets.MIPS64LE:
 		return pc - 8
-	case "s390x":
+	case targets.S390x:
 		return pc - 6
-	case "riscv64":
+	case targets.RiscV64:
 		return pc - 4
 	default:
 		panic(fmt.Sprintf("unknown arch %q", target.Arch))
@@ -860,16 +860,16 @@ func PreviousInstructionPC(target *targets.Target, pc uint64) uint64 {
 func archCallInsn(target *targets.Target) ([][]byte, [][]byte) {
 	callName := [][]byte{[]byte(" <__sanitizer_cov_trace_pc>")}
 	switch target.Arch {
-	case "386":
+	case targets.I386:
 		// c1000102:       call   c10001f0 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tcall ")}, callName
-	case "arm64":
+	case targets.ARM64:
 		// ffff0000080d9cc0:       bl      ffff00000820f478 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tbl\t")}, callName
-	case "arm":
+	case targets.ARM:
 		// 8010252c:       bl      801c3280 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tbl\t")}, callName
-	case "ppc64le":
+	case targets.PPC64LE:
 		// c00000000006d904:       bl      c000000000350780 <.__sanitizer_cov_trace_pc>
 		// This is only known to occur in the test:
 		// 838:   bl      824 <__sanitizer_cov_trace_pc+0x8>
@@ -880,15 +880,15 @@ func archCallInsn(target *targets.Target) ([][]byte, [][]byte) {
 			[]byte("<__sanitizer_cov_trace_pc+0x8>"),
 			[]byte(" <.__sanitizer_cov_trace_pc>"),
 		}
-	case "mips64le":
+	case targets.MIPS64LE:
 		// ffffffff80100420:       jal     ffffffff80205880 <__sanitizer_cov_trace_pc>
 		// This is only known to occur in the test:
 		// b58:   bal     b30 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tjal\t"), []byte("\tbal\t")}, callName
-	case "s390x":
+	case targets.S390x:
 		// 1001de:       brasl   %r14,2bc090 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tbrasl\t")}, callName
-	case "riscv64":
+	case targets.RiscV64:
 		// ffffffe000200018:       jal     ra,ffffffe0002935b0 <__sanitizer_cov_trace_pc>
 		// ffffffe0000010da:       jalr    1242(ra) # ffffffe0002935b0 <__sanitizer_cov_trace_pc>
 		return [][]byte{[]byte("\tjal\t"), []byte("\tjalr\t")}, callName
diff --git a/pkg/cover/report_test.go b/pkg/cover/report_test.go
index 7748c3fab..b48ea2370 100644
--- a/pkg/cover/report_test.go
+++ b/pkg/cover/report_test.go
@@ -68,7 +68,7 @@ func TestReportGenerator(t *testing.T) {
 	}
 	t.Parallel()
 	for os, arches := range targets.List {
-		if os == "test" {
+		if os == targets.TestOS {
 			continue
 		}
 		for _, target := range arches {
@@ -135,7 +135,7 @@ void __sanitizer_cov_trace_pc() { printf("%llu", (long long)__builtin_return_add
 		errText = strings.ReplaceAll(errText, "‘", "'")
 		errText = strings.ReplaceAll(errText, "’", "'")
 		if strings.Contains(errText, "error: unrecognized command line option '-fsanitize-coverage=trace-pc'") &&
-			(os.Getenv("SYZ_BIG_ENV") == "" || target.OS == "akaros") {
+			(os.Getenv("SYZ_BIG_ENV") == "" || target.OS == targets.Akaros) {
 			t.Skip("skipping test, -fsanitize-coverage=trace-pc is not supported")
 		}
 		t.Fatal(err)
diff --git a/pkg/csource/common.go b/pkg/csource/common.go
index 242190180..0dd76cfbb 100644
--- a/pkg/csource/common.go
+++ b/pkg/csource/common.go
@@ -19,11 +19,6 @@ import (
 )
 
 const (
-	linux   = "linux"
-	freebsd = "freebsd"
-	openbsd = "openbsd"
-	netbsd  = "netbsd"
-
 	sandboxNone      = "none"
 	sandboxSetuid    = "setuid"
 	sandboxNamespace = "namespace"
diff --git a/pkg/csource/csource.go b/pkg/csource/csource.go
index 488d277e1..49babbf41 100644
--- a/pkg/csource/csource.go
+++ b/pkg/csource/csource.go
@@ -166,7 +166,7 @@ func (ctx *context) generateSyscallDefines() string {
 		fmt.Fprintf(buf, "#define %v%v %v\n", prefix, name, ctx.calls[name])
 		fmt.Fprintf(buf, "#endif\n")
 	}
-	if ctx.target.OS == "linux" && ctx.target.PtrSize == 4 {
+	if ctx.target.OS == targets.Linux && ctx.target.PtrSize == 4 {
 		// This is a dirty hack.
 		// On 32-bit linux mmap translated to old_mmap syscall which has a different signature.
 		// mmap2 has the right signature. syz-extract translates mmap to mmap2, do the same here.
@@ -403,7 +403,7 @@ func (ctx *context) copyinVal(w *bytes.Buffer, addr, size uint64, val string, bf
 }
 
 func (ctx *context) copyout(w *bytes.Buffer, call prog.ExecCall, resCopyout bool) {
-	if ctx.sysTarget.OS == "fuchsia" {
+	if ctx.sysTarget.OS == targets.Fuchsia {
 		// On fuchsia we have real system calls that return ZX_OK on success,
 		// and libc calls that are casted to function returning intptr_t,
 		// as the result int -1 is returned as 0x00000000ffffffff rather than full -1.
@@ -523,7 +523,7 @@ func (ctx *context) hoistIncludes(result []byte) []byte {
 			sortedBottom = append(sortedBottom, include)
 		} else if strings.Contains(include, "<netinet/if_ether.h>") {
 			sortedBottom = append(sortedBottom, include)
-		} else if ctx.target.OS == freebsd && strings.Contains(include, "<sys/types.h>") {
+		} else if ctx.target.OS == targets.FreeBSD && strings.Contains(include, "<sys/types.h>") {
 			sortedTop = append(sortedTop, include)
 		} else {
 			sorted = append(sorted, include)
diff --git a/pkg/csource/csource_test.go b/pkg/csource/csource_test.go
index 3eec99792..f6d04b35c 100644
--- a/pkg/csource/csource_test.go
+++ b/pkg/csource/csource_test.go
@@ -136,7 +136,7 @@ func TestSysTests(t *testing.T) {
 		}
 		t.Run(target.OS+"/"+target.Arch, func(t *testing.T) {
 			t.Parallel()
-			dir := filepath.Join("..", "..", "sys", target.OS, "test")
+			dir := filepath.Join("..", "..", "sys", target.OS, targets.TestOS)
 			if !osutil.IsExist(dir) {
 				return
 			}
@@ -173,7 +173,7 @@ func TestSysTests(t *testing.T) {
 
 func TestExecutorMacros(t *testing.T) {
 	// Ensure that executor does not mis-spell any of the SYZ_* macros.
-	target, _ := prog.GetTarget("test", "64")
+	target, _ := prog.GetTarget(targets.TestOS, targets.TestArch64)
 	p := target.Generate(rand.NewSource(0), 1, target.DefaultChoiceTable())
 	expected := commonDefines(p, Options{})
 	expected["SYZ_EXECUTOR"] = true
diff --git a/pkg/csource/options.go b/pkg/csource/options.go
index ba74eb37c..7f2bc5109 100644
--- a/pkg/csource/options.go
+++ b/pkg/csource/options.go
@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // Options control various aspects of source generation.
@@ -113,10 +114,10 @@ func (opts Options) Check(OS string) error {
 }
 
 func (opts Options) checkLinuxOnly(OS string) error {
-	if OS == linux {
+	if OS == targets.Linux {
 		return nil
 	}
-	if opts.NetInjection && !(OS == openbsd || OS == freebsd || OS == netbsd) {
+	if opts.NetInjection && !(OS == targets.OpenBSD || OS == targets.FreeBSD || OS == targets.NetBSD) {
 		return fmt.Errorf("option NetInjection is not supported on %v", OS)
 	}
 	if opts.NetDevices {
@@ -150,7 +151,7 @@ func (opts Options) checkLinuxOnly(OS string) error {
 		return fmt.Errorf("option Wifi is not supported on %v", OS)
 	}
 	if opts.Sandbox == sandboxNamespace ||
-		(opts.Sandbox == sandboxSetuid && !(OS == openbsd || OS == freebsd || OS == netbsd)) ||
+		(opts.Sandbox == sandboxSetuid && !(OS == targets.OpenBSD || OS == targets.FreeBSD || OS == targets.NetBSD)) ||
 		opts.Sandbox == sandboxAndroid {
 		return fmt.Errorf("option Sandbox=%v is not supported on %v", opts.Sandbox, OS)
 	}
@@ -183,7 +184,7 @@ func DefaultOpts(cfg *mgrconfig.Config) Options {
 		HandleSegv:    true,
 		Repro:         true,
 	}
-	if cfg.TargetOS != linux {
+	if cfg.TargetOS != targets.Linux {
 		opts.NetInjection = false
 		opts.NetDevices = false
 		opts.NetReset = false
diff --git a/pkg/csource/options_test.go b/pkg/csource/options_test.go
index 1c403ae06..43cffd1d5 100644
--- a/pkg/csource/options_test.go
+++ b/pkg/csource/options_test.go
@@ -7,10 +7,12 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestParseOptions(t *testing.T) {
-	for _, opts := range allOptionsSingle("linux") {
+	for _, opts := range allOptionsSingle(targets.Linux) {
 		data := opts.Serialize()
 		got, err := DeserializeOptions(data)
 		if err != nil {
diff --git a/pkg/host/features.go b/pkg/host/features.go
index 8b78637fb..14d4f5c89 100644
--- a/pkg/host/features.go
+++ b/pkg/host/features.go
@@ -102,7 +102,7 @@ func Setup(target *prog.Target, features *Features, featureFlags csource.Feature
 	if features[FeatureFault].Enabled {
 		args = append(args, "fault")
 	}
-	if target.OS == "linux" && featureFlags["binfmt_misc"].Enabled {
+	if target.OS == targets.Linux && featureFlags["binfmt_misc"].Enabled {
 		args = append(args, "binfmt_misc")
 	}
 	if features[FeatureKCSAN].Enabled {
@@ -117,6 +117,6 @@ func Setup(target *prog.Target, features *Features, featureFlags csource.Feature
 
 func noHostChecks(target *prog.Target) bool {
 	// HostFuzzer targets can't run Go binaries on the targets,
-	// so we actually run on the host on another OS. The same for "test" OS.
-	return targets.Get(target.OS, target.Arch).HostFuzzer || target.OS == "test"
+	// so we actually run on the host on another OS. The same for targets.TestOS OS.
+	return targets.Get(target.OS, target.Arch).HostFuzzer || target.OS == targets.TestOS
 }
diff --git a/pkg/host/machine_info_linux_test.go b/pkg/host/machine_info_linux_test.go
index f09666659..5075751d5 100644
--- a/pkg/host/machine_info_linux_test.go
+++ b/pkg/host/machine_info_linux_test.go
@@ -10,6 +10,8 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestReadCPUInfoLinux(t *testing.T) {
@@ -42,14 +44,14 @@ func checkCPUInfo(t *testing.T, data []byte, arch string) {
 		keys[key] = true
 	}
 	importantKeys := map[string][]string{
-		"ppc64le":  {"cpu", "revision", "platform", "model", "machine"},
-		"amd64":    {"vendor_id", "model", "flags"},
-		"s390x":    {"vendor_id", "processor 0", "features"},
-		"386":      {"vendor_id", "model", "flags"},
-		"arm64":    {"CPU implementer", "CPU part", "Features"},
-		"arm":      {"CPU implementer", "CPU part", "Features"},
-		"mips64le": {"system type", "cpu model", "ASEs implemented"},
-		"riscv64":  {"processor", "isa", "mmu"},
+		targets.PPC64LE:  {"cpu", "revision", "platform", "model", "machine"},
+		targets.AMD64:    {"vendor_id", "model", "flags"},
+		targets.S390x:    {"vendor_id", "processor 0", "features"},
+		targets.I386:     {"vendor_id", "model", "flags"},
+		targets.ARM64:    {"CPU implementer", "CPU part", "Features"},
+		targets.ARM:      {"CPU implementer", "CPU part", "Features"},
+		targets.MIPS64LE: {"system type", "cpu model", "ASEs implemented"},
+		targets.RiscV64:  {"processor", "isa", "mmu"},
 	}
 	archKeys := importantKeys[arch]
 	if len(archKeys) == 0 {
@@ -149,7 +151,7 @@ type cannedTest struct {
 // nolint:lll
 var cpuInfoTests = []cannedTest{
 	{
-		arch: "ppc64le",
+		arch: targets.PPC64LE,
 		data: `
 processor	: 0
 cpu		: POWER8 (architected), altivec supported
@@ -179,7 +181,7 @@ MMU		: Hash
 `,
 	},
 	{
-		arch: "ppc64le",
+		arch: targets.PPC64LE,
 		data: `
 processor       : 0
 cpu             : POWER8 (architected), altivec supported
@@ -201,7 +203,7 @@ MMU             : Hash
 `,
 	},
 	{
-		arch: "ppc64le",
+		arch: targets.PPC64LE,
 		data: `
 processor       : 0
 cpu             : POWER8E, altivec supported
@@ -242,7 +244,7 @@ MMU             : Hash
 `,
 	},
 	{
-		arch: "amd64",
+		arch: targets.AMD64,
 		data: `
 processor	: 0
 vendor_id	: GenuineIntel
@@ -302,7 +304,7 @@ power management:
 `,
 	},
 	{
-		arch: "amd64",
+		arch: targets.AMD64,
 		data: `
 processor	: 0
 vendor_id	: GenuineIntel
diff --git a/pkg/host/syscalls_linux.go b/pkg/host/syscalls_linux.go
index ff41da68b..16cfbfa46 100644
--- a/pkg/host/syscalls_linux.go
+++ b/pkg/host/syscalls_linux.go
@@ -18,6 +18,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func isSupported(c *prog.Syscall, target *prog.Target, sandbox string) (bool, string) {
@@ -74,17 +75,17 @@ func parseKallsyms(kallsyms []byte, arch string) map[string]bool {
 	set := make(map[string]bool)
 	var re *regexp.Regexp
 	switch arch {
-	case "386", "amd64":
+	case targets.I386, targets.AMD64:
 		re = regexp.MustCompile(` T (__ia32_|__x64_)?sys_([^\n]+)\n`)
-	case "arm", "arm64":
+	case targets.ARM, targets.ARM64:
 		re = regexp.MustCompile(` T (__arm64_)?sys_([^\n]+)\n`)
-	case "ppc64le":
+	case targets.PPC64LE:
 		re = regexp.MustCompile(` T ()?sys_([^\n]+)\n`)
-	case "mips64le":
+	case targets.MIPS64LE:
 		re = regexp.MustCompile(` T sys_(mips_)?([^\n]+)\n`)
-	case "s390x":
+	case targets.S390x:
 		re = regexp.MustCompile(` T (__s390_|__s390x_)?sys_([^\n]+)\n`)
-	case "riscv64":
+	case targets.RiscV64:
 		re = regexp.MustCompile(` T sys_(riscv_)?([^\n]+)\n`)
 	default:
 		panic("unsupported arch for kallsyms parsing")
@@ -191,11 +192,11 @@ func isWifiEmulationSupported(c *prog.Syscall, target *prog.Target, sandbox stri
 func isSyzKvmSetupCPUSupported(c *prog.Syscall, target *prog.Target, sandbox string) (bool, string) {
 	switch c.Name {
 	case "syz_kvm_setup_cpu$x86":
-		if runtime.GOARCH == "amd64" || runtime.GOARCH == "386" {
+		if runtime.GOARCH == targets.AMD64 || runtime.GOARCH == targets.I386 {
 			return true, ""
 		}
 	case "syz_kvm_setup_cpu$arm64":
-		if runtime.GOARCH == "arm64" {
+		if runtime.GOARCH == targets.ARM64 {
 			return true, ""
 		}
 	}
diff --git a/pkg/host/syscalls_linux_test.go b/pkg/host/syscalls_linux_test.go
index 3ce2e3517..5d4f60082 100644
--- a/pkg/host/syscalls_linux_test.go
+++ b/pkg/host/syscalls_linux_test.go
@@ -11,11 +11,12 @@ import (
 	"testing"
 
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestSupportedSyscalls(t *testing.T) {
 	t.Parallel()
-	target, err := prog.GetTarget("linux", runtime.GOARCH)
+	target, err := prog.GetTarget(targets.Linux, runtime.GOARCH)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -58,7 +59,7 @@ func TestKallsymsParse(t *testing.T) {
 		SupportedSyscalls []string
 	}{
 		{
-			"amd64",
+			targets.AMD64,
 			[]byte(`
 ffffffff817cdcc0 T __sys_bind
 ffffffff817cdda0 T __x64_sys_bind
@@ -74,7 +75,7 @@ ffffffff817ce0a0 T __ia32_sys_accept4
 			[]string{"bind", "listen", "accept4"},
 		},
 		{
-			"arm64",
+			targets.ARM64,
 			[]byte(`
 ffff000010a3ddf8 T __sys_bind
 ffff000010a3def8 T __arm64_sys_bind
@@ -87,7 +88,7 @@ ffff000010a3e1f0 T __arm64_sys_accept4
 			[]string{"bind", "listen", "accept4"},
 		},
 		{
-			"ppc64le",
+			targets.PPC64LE,
 			[]byte(`
 c0000000011ec810 T __sys_bind
 c0000000011eca10 T sys_bind
@@ -103,7 +104,7 @@ c0000000011ed050 T __se_sys_accept4
 			[]string{"bind", "listen", "accept4"},
 		},
 		{
-			"arm",
+			targets.ARM,
 			[]byte(`
 c037c67c T __se_sys_setfsuid
 c037c694 T __sys_setfsgid
@@ -118,7 +119,7 @@ c037c7f8 T sys_getppid
 		},
 		// Test kallsymsRenameMap.
 		{
-			"ppc64le",
+			targets.PPC64LE,
 			[]byte(`
 c00000000037eb00 T sys_newstat
 			`),
@@ -126,7 +127,7 @@ c00000000037eb00 T sys_newstat
 			[]string{"stat"},
 		},
 		{
-			"s390x",
+			targets.S390x,
 			[]byte(`
 0000000000e4f760 T __sys_bind
 0000000000e4f8e8 T __s390_sys_bind
@@ -145,7 +146,7 @@ c00000000037eb00 T sys_newstat
 			[]string{"bind", "listen", "accept4"},
 		},
 		{
-			"riscv64",
+			targets.RiscV64,
 			[]byte(`
 ffffffe0005c9b02 T __sys_bind
 ffffffe0005c9ba0 T sys_bind
diff --git a/pkg/instance/instance.go b/pkg/instance/instance.go
index b5cbd3bd2..467998a60 100644
--- a/pkg/instance/instance.go
+++ b/pkg/instance/instance.go
@@ -318,7 +318,7 @@ func (inst *inst) testInstance() error {
 		}
 	}
 
-	cmd := OldFuzzerCmd(fuzzerBin, executorCmd, "test", inst.cfg.TargetOS, inst.cfg.TargetArch, fwdAddr,
+	cmd := OldFuzzerCmd(fuzzerBin, executorCmd, targets.TestOS, inst.cfg.TargetOS, inst.cfg.TargetArch, fwdAddr,
 		inst.cfg.Sandbox, 0, inst.cfg.Cover, true)
 	outc, errc, err := inst.vm.Run(10*time.Minute, nil, cmd)
 	if err != nil {
@@ -470,7 +470,7 @@ func ExecprogCmd(execprog, executor, OS, arch, sandbox string, repeat, threaded,
 }
 
 var MakeBin = func() string {
-	if runtime.GOOS == "freebsd" || runtime.GOOS == "openbsd" {
+	if runtime.GOOS == targets.FreeBSD || runtime.GOOS == targets.OpenBSD {
 		return "gmake"
 	}
 	return "make"
diff --git a/pkg/instance/instance_test.go b/pkg/instance/instance_test.go
index 5b9a28404..e19f91faf 100644
--- a/pkg/instance/instance_test.go
+++ b/pkg/instance/instance_test.go
@@ -9,6 +9,8 @@ import (
 	"runtime"
 	"strings"
 	"testing"
+
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestFuzzerCmd(t *testing.T) {
@@ -29,7 +31,7 @@ func TestFuzzerCmd(t *testing.T) {
 	flagSandbox := flags.String("sandbox", "none", "sandbox for fuzzing (none/setuid/namespace)")
 	flagDebug := flags.Bool("debug", false, "debug output from executor")
 	flagV := flags.Int("v", 0, "verbosity")
-	cmdLine := OldFuzzerCmd(os.Args[0], "/myexecutor", "myname", "linux", "386", "localhost:1234",
+	cmdLine := OldFuzzerCmd(os.Args[0], "/myexecutor", "myname", targets.Linux, targets.I386, "localhost:1234",
 		"namespace", 3, true, true)
 	args := strings.Split(cmdLine, " ")[1:]
 	if err := flags.Parse(args); err != nil {
@@ -38,8 +40,8 @@ func TestFuzzerCmd(t *testing.T) {
 	if *flagName != "myname" {
 		t.Errorf("bad name: %q, want: %q", *flagName, "myname")
 	}
-	if *flagArch != "386" {
-		t.Errorf("bad arch: %q, want: %q", *flagArch, "386")
+	if *flagArch != targets.I386 {
+		t.Errorf("bad arch: %q, want: %q", *flagArch, targets.I386)
 	}
 	if *flagManager != "localhost:1234" {
 		t.Errorf("bad manager: %q, want: %q", *flagManager, "localhost:1234")
@@ -91,7 +93,8 @@ func TestExecprogCmd(t *testing.T) {
 	flagCollide := flags.Bool("collide", true, "collide syscalls to provoke data races")
 	flagSignal := flags.Bool("cover", false, "collect feedback signals (coverage)")
 	flagSandbox := flags.String("sandbox", "none", "sandbox for fuzzing (none/setuid/namespace)")
-	cmdLine := ExecprogCmd(os.Args[0], "/myexecutor", "freebsd", "386", "namespace", true, false, false, 7, 2, 3, "myprog")
+	cmdLine := ExecprogCmd(os.Args[0], "/myexecutor", targets.FreeBSD, targets.I386,
+		"namespace", true, false, false, 7, 2, 3, "myprog")
 	args := strings.Split(cmdLine, " ")[1:]
 	if err := flags.Parse(args); err != nil {
 		t.Fatal(err)
@@ -102,8 +105,8 @@ func TestExecprogCmd(t *testing.T) {
 	if *flagOS != runtime.GOOS {
 		t.Errorf("bad os: %q, want: %q", *flagOS, runtime.GOOS)
 	}
-	if *flagArch != "386" {
-		t.Errorf("bad arch: %q, want: %q", *flagArch, "386")
+	if *flagArch != targets.I386 {
+		t.Errorf("bad arch: %q, want: %q", *flagArch, targets.I386)
 	}
 	if *flagRepeat != 0 {
 		t.Errorf("bad repeat: %v, want: %v", *flagRepeat, 0)
diff --git a/pkg/ipc/ipc.go b/pkg/ipc/ipc.go
index ffa8a4e6f..06b39af9d 100644
--- a/pkg/ipc/ipc.go
+++ b/pkg/ipc/ipc.go
@@ -268,7 +268,7 @@ func (env *Env) Exec(opts *ExecOpts, p *prog.Prog) (output []byte, info *ProgInf
 
 	atomic.AddUint64(&env.StatExecs, 1)
 	if env.cmd == nil {
-		if p.Target.OS != "test" && targets.Get(p.Target.OS, p.Target.Arch).HostFuzzer {
+		if p.Target.OS != targets.TestOS && targets.Get(p.Target.OS, p.Target.Arch).HostFuzzer {
 			// The executor is actually ssh,
 			// starting them too frequently leads to timeouts.
 			<-rateLimit.C
diff --git a/pkg/ipc/ipc_test.go b/pkg/ipc/ipc_test.go
index c8210cdcd..e7c9aa0f8 100644
--- a/pkg/ipc/ipc_test.go
+++ b/pkg/ipc/ipc_test.go
@@ -73,7 +73,7 @@ func TestExecutor(t *testing.T) {
 			bin := buildExecutor(t, target)
 			defer os.Remove(bin)
 			// qemu-user may allow us to run some cross-arch binaries.
-			if _, err := osutil.RunCmd(time.Minute, "", bin, "test"); err != nil {
+			if _, err := osutil.RunCmd(time.Minute, "", bin, targets.TestOS); err != nil {
 				if sysTarget.Arch == runtime.GOOS || sysTarget.VMArch == runtime.GOOS {
 					t.Fatal(err)
 				}
diff --git a/pkg/report/fuzz.go b/pkg/report/fuzz.go
index 0db602491..f812f78eb 100644
--- a/pkg/report/fuzz.go
+++ b/pkg/report/fuzz.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func Fuzz(data []byte) int {
@@ -32,7 +33,7 @@ func Fuzz(data []byte) int {
 		if len(rep.Output) == 0 {
 			panic(fmt.Sprintf("%v: len(Output) == 0", typ))
 		}
-		if os == "fuchsia" {
+		if os == targets.Fuchsia {
 			// Fuchsia has Start/End/SkipPos set incorrectly because it symbolizes before parsing.
 			continue
 		}
@@ -66,12 +67,12 @@ func Fuzz(data []byte) int {
 var fuzzReporters = func() map[string]Reporter {
 	reporters := make(map[string]Reporter)
 	for os := range ctors {
-		if os == "windows" {
+		if os == targets.Windows {
 			continue
 		}
 		cfg := &mgrconfig.Config{
 			TargetOS:   os,
-			TargetArch: "amd64",
+			TargetArch: targets.AMD64,
 		}
 		reporter, err := NewReporter(cfg)
 		if err != nil {
diff --git a/pkg/report/linux_test.go b/pkg/report/linux_test.go
index 2e31ee755..d1b343efe 100644
--- a/pkg/report/linux_test.go
+++ b/pkg/report/linux_test.go
@@ -9,12 +9,13 @@ import (
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/symbolizer"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestLinuxIgnores(t *testing.T) {
 	cfg := &mgrconfig.Config{
-		TargetOS:   "linux",
-		TargetArch: "amd64",
+		TargetOS:   targets.Linux,
+		TargetArch: targets.AMD64,
 	}
 	reporter, err := NewReporter(cfg)
 	if err != nil {
diff --git a/pkg/report/report.go b/pkg/report/report.go
index ae618d6e6..13f76e67d 100644
--- a/pkg/report/report.go
+++ b/pkg/report/report.go
@@ -132,14 +132,14 @@ const (
 )
 
 var ctors = map[string]fn{
-	"akaros":  ctorAkaros,
-	"linux":   ctorLinux,
-	"gvisor":  ctorGvisor,
-	"freebsd": ctorFreebsd,
-	"netbsd":  ctorNetbsd,
-	"openbsd": ctorOpenbsd,
-	"fuchsia": ctorFuchsia,
-	"windows": ctorStub,
+	targets.Akaros:  ctorAkaros,
+	targets.Linux:   ctorLinux,
+	"gvisor":        ctorGvisor,
+	targets.FreeBSD: ctorFreebsd,
+	targets.NetBSD:  ctorNetbsd,
+	targets.OpenBSD: ctorOpenbsd,
+	targets.Fuchsia: ctorFuchsia,
+	targets.Windows: ctorStub,
 }
 
 type config struct {
diff --git a/pkg/report/report_test.go b/pkg/report/report_test.go
index 1545a44e9..eebbb4c22 100644
--- a/pkg/report/report_test.go
+++ b/pkg/report/report_test.go
@@ -16,6 +16,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 var flagUpdate = flag.Bool("update", false, "update test files accordingly to current results")
@@ -303,12 +304,12 @@ func testGuiltyFile(t *testing.T, reporter Reporter, fn string) {
 
 func forEachFile(t *testing.T, dir string, fn func(t *testing.T, reporter Reporter, fn string)) {
 	for os := range ctors {
-		if os == "windows" {
+		if os == targets.Windows {
 			continue // not implemented
 		}
 		cfg := &mgrconfig.Config{
 			TargetOS:   os,
-			TargetArch: "amd64",
+			TargetArch: targets.AMD64,
 		}
 		reporter, err := NewReporter(cfg)
 		if err != nil {
diff --git a/pkg/repro/repro_test.go b/pkg/repro/repro_test.go
index 3fd9eb1b3..9b639cd7d 100644
--- a/pkg/repro/repro_test.go
+++ b/pkg/repro/repro_test.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/csource"
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func initTest(t *testing.T) (*rand.Rand, int) {
@@ -92,7 +93,7 @@ func TestSimplifies(t *testing.T) {
 	}
 	var check func(opts csource.Options, i int)
 	check = func(opts csource.Options, i int) {
-		if err := opts.Check("linux"); err != nil {
+		if err := opts.Check(targets.Linux); err != nil {
 			t.Fatalf("opts are invalid: %v", err)
 		}
 		if i == len(cSimplifies) {
diff --git a/pkg/runtest/run.go b/pkg/runtest/run.go
index 2352028fe..8366b8fb3 100644
--- a/pkg/runtest/run.go
+++ b/pkg/runtest/run.go
@@ -430,7 +430,7 @@ func (ctx *Context) createCTest(p *prog.Prog, sandbox string, threaded bool, tim
 		Sandbox:     sandbox,
 		UseTmpDir:   true,
 		HandleSegv:  true,
-		Cgroups:     p.Target.OS == "linux" && sandbox != "",
+		Cgroups:     p.Target.OS == targets.Linux && sandbox != "",
 		Trace:       true,
 	}
 	if sandbox != "" {
@@ -512,7 +512,7 @@ func checkCallResult(req *RunRequest, isC bool, run, call int, info *ipc.ProgInf
 				continue
 			}
 		}
-		if runtime.GOOS == "freebsd" && flag == ipc.CallBlocked {
+		if runtime.GOOS == targets.FreeBSD && flag == ipc.CallBlocked {
 			// Blocking detection is flaky on freebsd.
 			// TODO(dvyukov): try to increase the timeout in executor to make it non-flaky.
 			continue
diff --git a/pkg/runtest/run_test.go b/pkg/runtest/run_test.go
index e4712033e..d72f5940e 100644
--- a/pkg/runtest/run_test.go
+++ b/pkg/runtest/run_test.go
@@ -26,12 +26,12 @@ var flagFilter = flag.String("filter", "", "prefix to match test file names")
 
 func Test(t *testing.T) {
 	switch runtime.GOOS {
-	case "openbsd":
+	case targets.OpenBSD:
 		t.Skipf("broken on %v", runtime.GOOS)
 	}
 	// Test only one target in short mode (each takes 5+ seconds to run).
-	shortTarget := targets.Get("test", "64")
-	for _, sysTarget := range targets.List["test"] {
+	shortTarget := targets.Get(targets.TestOS, targets.TestArch64)
+	for _, sysTarget := range targets.List[targets.TestOS] {
 		if testing.Short() && sysTarget != shortTarget {
 			continue
 		}
@@ -80,7 +80,7 @@ func test(t *testing.T, sysTarget *targets.Target) {
 		}
 	}()
 	ctx := &Context{
-		Dir:          filepath.Join("..", "..", "sys", target.OS, "test"),
+		Dir:          filepath.Join("..", "..", "sys", target.OS, targets.TestOS),
 		Target:       target,
 		Tests:        *flagFilter,
 		Features:     features,
@@ -100,7 +100,7 @@ func test(t *testing.T, sysTarget *targets.Target) {
 
 func TestParsing(t *testing.T) {
 	for OS, arches := range targets.List {
-		dir := filepath.Join("..", "..", "sys", OS, "test")
+		dir := filepath.Join("..", "..", "sys", OS, targets.TestOS)
 		if !osutil.IsExist(dir) {
 			continue
 		}
diff --git a/pkg/vcs/vcs.go b/pkg/vcs/vcs.go
index 4185bf165..df3099225 100644
--- a/pkg/vcs/vcs.go
+++ b/pkg/vcs/vcs.go
@@ -16,6 +16,7 @@ import (
 
 	"github.com/google/syzkaller/dashboard/dashapi"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 type RecipientType int
@@ -168,19 +169,19 @@ const (
 
 func NewRepo(os, vm, dir string, opts ...RepoOpt) (Repo, error) {
 	switch os {
-	case "linux":
+	case targets.Linux:
 		return newLinux(dir, opts), nil
-	case "akaros":
+	case targets.Akaros:
 		return newAkaros(dir, opts), nil
-	case "fuchsia":
+	case targets.Fuchsia:
 		return newFuchsia(dir, opts), nil
-	case "openbsd":
+	case targets.OpenBSD:
 		return newGit(dir, nil, opts), nil
-	case "netbsd":
+	case targets.NetBSD:
 		return newGit(dir, nil, opts), nil
-	case "freebsd":
+	case targets.FreeBSD:
 		return newGit(dir, nil, opts), nil
-	case "test":
+	case targets.TestOS:
 		return newTestos(dir, opts), nil
 	}
 	return nil, fmt.Errorf("vcs is unsupported for %v", os)
diff --git a/prog/test/fuzz.go b/prog/test/fuzz.go
index f3742f6c3..0d2807f7f 100644
--- a/prog/test/fuzz.go
+++ b/prog/test/fuzz.go
@@ -9,6 +9,7 @@ import (
 	"math/rand"
 
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 	_ "github.com/google/syzkaller/sys/test/gen" // import the target we use for fuzzing
 )
 
@@ -66,7 +67,7 @@ func FuzzParseLog(data []byte) int {
 var fuzzBuffer = make([]byte, prog.ExecBufferSize)
 var fuzzTarget, fuzzChoiceTable = func() (*prog.Target, *prog.ChoiceTable) {
 	prog.Debug()
-	target, err := prog.GetTarget("test", "64")
+	target, err := prog.GetTarget(targets.TestOS, targets.TestArch64)
 	if err != nil {
 		panic(err)
 	}
diff --git a/sys/fuchsia/fidlgen/main.go b/sys/fuchsia/fidlgen/main.go
index 8c48ac312..b4942a08d 100644
--- a/sys/fuchsia/fidlgen/main.go
+++ b/sys/fuchsia/fidlgen/main.go
@@ -19,7 +19,7 @@ import (
 
 func main() {
 	targetArch := os.Getenv("TARGETARCH")
-	target := targets.Get("fuchsia", targetArch)
+	target := targets.Get(targets.Fuchsia, targetArch)
 	if target == nil {
 		failf("unknown TARGETARCH %s", targetArch)
 	}
diff --git a/sys/linux/init.go b/sys/linux/init.go
index 928ba17e5..a18fa99c4 100644
--- a/sys/linux/init.go
+++ b/sys/linux/init.go
@@ -79,11 +79,11 @@ func InitTarget(target *prog.Target) {
 	}
 
 	switch target.Arch {
-	case "amd64":
+	case targets.AMD64:
 		target.SpecialPointers = []uint64{
 			0xffffffff81000000, // kernel text
 		}
-	case "386", "arm64", "arm", "ppc64le", "mips64le", "s390x", "riscv64":
+	case targets.I386, targets.ARM64, targets.ARM, targets.PPC64LE, targets.MIPS64LE, targets.S390x, targets.RiscV64:
 	default:
 		panic("unknown arch")
 	}
diff --git a/sys/linux/init_test.go b/sys/linux/init_test.go
index df0622ba3..201ce762b 100644
--- a/sys/linux/init_test.go
+++ b/sys/linux/init_test.go
@@ -8,10 +8,11 @@ import (
 
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys/linux/gen"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestNeutralize(t *testing.T) {
-	prog.TestDeserializeHelper(t, "linux", "amd64", nil, []prog.DeserializeTest{
+	prog.TestDeserializeHelper(t, targets.Linux, targets.AMD64, nil, []prog.DeserializeTest{
 		{
 			In:  `syslog(0x10000000006, 0x0, 0x0)`,
 			Out: `syslog(0x9, 0x0, 0x0)`,
diff --git a/sys/openbsd/init_test.go b/sys/openbsd/init_test.go
index 7f3d9a489..3a6c2c14c 100644
--- a/sys/openbsd/init_test.go
+++ b/sys/openbsd/init_test.go
@@ -8,10 +8,11 @@ import (
 
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys/openbsd/gen"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 func TestNeutralize(t *testing.T) {
-	prog.TestDeserializeHelper(t, "openbsd", "amd64", nil, []prog.DeserializeTest{
+	prog.TestDeserializeHelper(t, targets.OpenBSD, targets.AMD64, nil, []prog.DeserializeTest{
 		{
 			In:  `chflagsat(0x0, 0x0, 0x60004, 0x0)`,
 			Out: `chflagsat(0x0, 0x0, 0x0, 0x0)`,
diff --git a/sys/syz-extract/extract.go b/sys/syz-extract/extract.go
index 10b8b6541..a1ddaa86c 100644
--- a/sys/syz-extract/extract.go
+++ b/sys/syz-extract/extract.go
@@ -57,15 +57,15 @@ type Extractor interface {
 }
 
 var extractors = map[string]Extractor{
-	"akaros":  new(akaros),
-	"linux":   new(linux),
-	"freebsd": new(freebsd),
-	"netbsd":  new(netbsd),
-	"openbsd": new(openbsd),
-	"android": new(linux),
-	"fuchsia": new(fuchsia),
-	"windows": new(windows),
-	"trusty":  new(trusty),
+	targets.Akaros:  new(akaros),
+	targets.Linux:   new(linux),
+	targets.FreeBSD: new(freebsd),
+	targets.NetBSD:  new(netbsd),
+	targets.OpenBSD: new(openbsd),
+	"android":       new(linux),
+	targets.Fuchsia: new(fuchsia),
+	targets.Windows: new(windows),
+	targets.Trusty:  new(trusty),
 }
 
 func main() {
@@ -243,7 +243,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string,
 	android := false
 	if os == "android" {
 		android = true
-		os = "linux"
+		os = targets.Linux
 	}
 	var arches []string
 	if arch != "" {
@@ -253,7 +253,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string,
 			arches = append(arches, arch)
 		}
 		if android {
-			arches = []string{"386", "amd64", "arm", "arm64"}
+			arches = []string{targets.I386, targets.AMD64, targets.ARM, targets.ARM64}
 		}
 		sort.Strings(arches)
 	}
@@ -278,7 +278,7 @@ func archFileList(os, arch string, files []string) (string, []string, []string,
 		}
 		for _, f := range matches {
 			f = filepath.Base(f)
-			if manualFiles[f] || os == "linux" && android != androidFiles[f] {
+			if manualFiles[f] || os == targets.Linux && android != androidFiles[f] {
 				continue
 			}
 			files = append(files, f)
diff --git a/sys/syz-extract/linux.go b/sys/syz-extract/linux.go
index 05789ef55..47e5d20e6 100644
--- a/sys/syz-extract/linux.go
+++ b/sys/syz-extract/linux.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/compiler"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 type linux struct{}
@@ -134,7 +135,8 @@ func (*linux) prepareArch(arch *Arch) error {
 }
 
 func (*linux) processFile(arch *Arch, info *compiler.ConstInfo) (map[string]uint64, map[string]bool, error) {
-	if strings.HasSuffix(info.File, "_kvm.txt") && (arch.target.Arch == "arm" || arch.target.Arch == "riscv64") {
+	if strings.HasSuffix(info.File, "_kvm.txt") &&
+		(arch.target.Arch == targets.ARM || arch.target.Arch == targets.RiscV64) {
 		// Hack: KVM is not supported on ARM anymore. We may want some more official support
 		// for marking descriptions arch-specific, but so far this combination is the only
 		// one. For riscv64, KVM is not supported yet but might be in the future.
diff --git a/sys/syz-sysgen/sysgen.go b/sys/syz-sysgen/sysgen.go
index 8dfedb6a2..62f36c3d3 100644
--- a/sys/syz-sysgen/sysgen.go
+++ b/sys/syz-sysgen/sysgen.go
@@ -115,7 +115,7 @@ func main() {
 				}
 				consts := constFile.Arch(job.Target.Arch)
 				top := descriptions
-				if OS == "linux" && (job.Target.Arch == "arm" || job.Target.Arch == "riscv64") {
+				if OS == targets.Linux && (job.Target.Arch == targets.ARM || job.Target.Arch == targets.RiscV64) {
 					// Hack: KVM is not supported on ARM anymore. On riscv64 it
 					// is not supported yet but might be in the future.
 					// Note: syz-extract also ignores this file for arm and
@@ -125,7 +125,7 @@ func main() {
 						return !strings.HasSuffix(pos.File, "_kvm.txt")
 					})
 				}
-				if OS == "test" {
+				if OS == targets.TestOS {
 					constInfo := compiler.ExtractConsts(top, job.Target, eh)
 					compiler.FabricateSyscallConsts(job.Target, constInfo, consts)
 				}
diff --git a/sys/targets/targets.go b/sys/targets/targets.go
index 28ee5b376..ff218aa6c 100644
--- a/sys/targets/targets.go
+++ b/sys/targets/targets.go
@@ -78,6 +78,31 @@ type osCommon struct {
 	cflags []string
 }
 
+const (
+	Akaros  = "akaros"
+	FreeBSD = "freebsd"
+	Fuchsia = "fuchsia"
+	Linux   = "linux"
+	NetBSD  = "netbsd"
+	OpenBSD = "openbsd"
+	TestOS  = "test"
+	Trusty  = "trusty"
+	Windows = "windows"
+
+	AMD64               = "amd64"
+	ARM64               = "arm64"
+	ARM                 = "arm"
+	I386                = "386"
+	MIPS64LE            = "mips64le"
+	PPC64LE             = "ppc64le"
+	S390x               = "s390x"
+	RiscV64             = "riscv64"
+	TestArch64          = "64"
+	TestArch64Fork      = "64_fork"
+	TestArch32Shmem     = "32_shmem"
+	TestArch32ForkShmem = "32_fork_shmem"
+)
+
 func Get(OS, arch string) *Target {
 	return GetEx(OS, arch, useClang)
 }
@@ -103,8 +128,8 @@ func GetEx(OS, arch string, clang bool) *Target {
 
 // nolint: lll
 var List = map[string]map[string]*Target{
-	"test": {
-		"64": {
+	TestOS: {
+		TestArch64: {
 			PtrSize:  8,
 			PageSize: 4 << 10,
 			// Compile with -no-pie due to issues with ASan + ASLR on ppc64le.
@@ -116,7 +141,7 @@ var List = map[string]map[string]*Target{
 				ExecutorUsesForkServer: false,
 			},
 		},
-		"64_fork": {
+		TestArch64Fork: {
 			PtrSize:  8,
 			PageSize: 8 << 10,
 			// Compile with -no-pie due to issues with ASan + ASLR on ppc64le.
@@ -128,7 +153,7 @@ var List = map[string]map[string]*Target{
 				ExecutorUsesForkServer: true,
 			},
 		},
-		"32_shmem": {
+		TestArch32Shmem: {
 			PtrSize:        4,
 			PageSize:       8 << 10,
 			Int64Alignment: 4,
@@ -141,7 +166,7 @@ var List = map[string]map[string]*Target{
 				ExecutorUsesForkServer: false,
 			},
 		},
-		"32_fork_shmem": {
+		TestArch32ForkShmem: {
 			PtrSize:  4,
 			PageSize: 4 << 10,
 			CFlags:   []string{"-m32", "-static"},
@@ -155,8 +180,8 @@ var List = map[string]map[string]*Target{
 			},
 		},
 	},
-	"linux": {
-		"amd64": {
+	Linux: {
+		AMD64: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -170,8 +195,8 @@ var List = map[string]map[string]*Target{
 				return nr >= 313
 			},
 		},
-		"386": {
-			VMArch:           "amd64",
+		I386: {
+			VMArch:           AMD64,
 			PtrSize:          4,
 			PageSize:         4 << 10,
 			Int64Alignment:   4,
@@ -181,7 +206,7 @@ var List = map[string]map[string]*Target{
 			KernelArch:       "i386",
 			KernelHeaderArch: "x86",
 		},
-		"arm64": {
+		ARM64: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -189,8 +214,8 @@ var List = map[string]map[string]*Target{
 			KernelArch:       "arm64",
 			KernelHeaderArch: "arm64",
 		},
-		"arm": {
-			VMArch:           "arm64",
+		ARM: {
+			VMArch:           ARM64,
 			PtrSize:          4,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -199,8 +224,7 @@ var List = map[string]map[string]*Target{
 			KernelArch:       "arm",
 			KernelHeaderArch: "arm",
 		},
-		"mips64le": {
-			VMArch:           "mips64le",
+		MIPS64LE: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -209,7 +233,7 @@ var List = map[string]map[string]*Target{
 			KernelArch:       "mips",
 			KernelHeaderArch: "mips",
 		},
-		"ppc64le": {
+		PPC64LE: {
 			PtrSize:          8,
 			PageSize:         64 << 10,
 			LittleEndian:     true,
@@ -218,7 +242,7 @@ var List = map[string]map[string]*Target{
 			KernelArch:       "powerpc",
 			KernelHeaderArch: "powerpc",
 		},
-		"s390x": {
+		S390x: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			DataOffset:       0xfffff000,
@@ -234,7 +258,7 @@ var List = map[string]map[string]*Target{
 				"mmap": "mmap",
 			},
 		},
-		"riscv64": {
+		RiscV64: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -243,8 +267,8 @@ var List = map[string]map[string]*Target{
 			KernelHeaderArch: "riscv",
 		},
 	},
-	"freebsd": {
-		"amd64": {
+	FreeBSD: {
+		AMD64: {
 			PtrSize:           8,
 			PageSize:          4 << 10,
 			LittleEndian:      true,
@@ -252,8 +276,8 @@ var List = map[string]map[string]*Target{
 			CFlags:            []string{"-m64"},
 			NeedSyscallDefine: dontNeedSyscallDefine,
 		},
-		"386": {
-			VMArch:   "amd64",
+		I386: {
+			VMArch:   AMD64,
 			PtrSize:  4,
 			PageSize: 4 << 10,
 			// The default DataOffset doesn't work with 32-bit
@@ -266,8 +290,8 @@ var List = map[string]map[string]*Target{
 			NeedSyscallDefine: dontNeedSyscallDefine,
 		},
 	},
-	"netbsd": {
-		"amd64": {
+	NetBSD: {
+		AMD64: {
 			PtrSize:      8,
 			PageSize:     4 << 10,
 			LittleEndian: true,
@@ -279,8 +303,8 @@ var List = map[string]map[string]*Target{
 			CCompiler: sourceDirVar + "/tools/bin/x86_64--netbsd-g++",
 		},
 	},
-	"openbsd": {
-		"amd64": {
+	OpenBSD: {
+		AMD64: {
 			PtrSize:      8,
 			PageSize:     4 << 10,
 			LittleEndian: true,
@@ -313,8 +337,8 @@ var List = map[string]map[string]*Target{
 			},
 		},
 	},
-	"fuchsia": {
-		"amd64": {
+	Fuchsia: {
+		AMD64: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
@@ -323,26 +347,26 @@ var List = map[string]map[string]*Target{
 			Objdump:          sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/llvm-objdump",
 			CFlags:           fuchsiaCFlags("x64", "x86_64"),
 		},
-		"arm64": {
+		ARM64: {
 			PtrSize:          8,
 			PageSize:         4 << 10,
 			LittleEndian:     true,
-			KernelHeaderArch: "arm64",
+			KernelHeaderArch: ARM64,
 			CCompiler:        sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/clang",
 			Objdump:          sourceDirVar + "/prebuilt/third_party/clang/linux-x64/bin/llvm-objdump",
-			CFlags:           fuchsiaCFlags("arm64", "aarch64"),
+			CFlags:           fuchsiaCFlags(ARM64, "aarch64"),
 		},
 	},
-	"windows": {
-		"amd64": {
+	Windows: {
+		AMD64: {
 			PtrSize: 8,
 			// TODO(dvyukov): what should we do about 4k vs 64k?
 			PageSize:     4 << 10,
 			LittleEndian: true,
 		},
 	},
-	"akaros": {
-		"amd64": {
+	Akaros: {
+		AMD64: {
 			PtrSize:           8,
 			PageSize:          4 << 10,
 			LittleEndian:      true,
@@ -354,8 +378,8 @@ var List = map[string]map[string]*Target{
 			},
 		},
 	},
-	"trusty": {
-		"arm": {
+	Trusty: {
+		ARM: {
 			PtrSize:           4,
 			PageSize:          4 << 10,
 			LittleEndian:      true,
@@ -365,7 +389,7 @@ var List = map[string]map[string]*Target{
 }
 
 var oses = map[string]osCommon{
-	"linux": {
+	Linux: {
 		SyscallNumbers:         true,
 		SyscallPrefix:          "__NR_",
 		ExecutorUsesShmem:      true,
@@ -373,7 +397,7 @@ var oses = map[string]osCommon{
 		KernelObject:           "vmlinux",
 		cflags:                 []string{"-static"},
 	},
-	"freebsd": {
+	FreeBSD: {
 		SyscallNumbers:         true,
 		Int64SyscallArgs:       true,
 		SyscallPrefix:          "SYS_",
@@ -383,15 +407,15 @@ var oses = map[string]osCommon{
 		CPP:                    "g++",
 		cflags:                 []string{"-static", "-lc++"},
 	},
-	"netbsd": {
-		BuildOS:                "linux",
+	NetBSD: {
+		BuildOS:                Linux,
 		SyscallNumbers:         true,
 		SyscallPrefix:          "SYS_",
 		ExecutorUsesShmem:      true,
 		ExecutorUsesForkServer: true,
 		KernelObject:           "netbsd.gdb",
 	},
-	"openbsd": {
+	OpenBSD: {
 		SyscallNumbers:         true,
 		SyscallPrefix:          "SYS_",
 		ExecutorUsesShmem:      true,
@@ -399,8 +423,8 @@ var oses = map[string]osCommon{
 		KernelObject:           "bsd.gdb",
 		CPP:                    "ecpp",
 	},
-	"fuchsia": {
-		BuildOS:                "linux",
+	Fuchsia: {
+		BuildOS:                Linux,
 		SyscallNumbers:         false,
 		ExecutorUsesShmem:      false,
 		ExecutorUsesForkServer: false,
@@ -408,15 +432,15 @@ var oses = map[string]osCommon{
 		SyzExecutorCmd:         "syz-executor",
 		KernelObject:           "zircon.elf",
 	},
-	"windows": {
+	Windows: {
 		SyscallNumbers:         false,
 		ExecutorUsesShmem:      false,
 		ExecutorUsesForkServer: false,
 		ExeExtension:           ".exe",
 		KernelObject:           "vmlinux",
 	},
-	"akaros": {
-		BuildOS:                "linux",
+	Akaros: {
+		BuildOS:                Linux,
 		SyscallNumbers:         true,
 		SyscallPrefix:          "SYS_",
 		ExecutorUsesShmem:      false,
@@ -424,7 +448,7 @@ var oses = map[string]osCommon{
 		HostFuzzer:             true,
 		KernelObject:           "akaros-kernel-64b",
 	},
-	"trusty": {
+	Trusty: {
 		SyscallNumbers:   true,
 		Int64SyscallArgs: true,
 		SyscallPrefix:    "__NR_",
@@ -479,14 +503,14 @@ func init() {
 	goarch := runtime.GOARCH
 	goos := runtime.GOOS
 	if goos == "android" {
-		goos = "linux"
+		goos = Linux
 	}
-	for _, target := range List["test"] {
+	for _, target := range List[TestOS] {
 		if List[goos] != nil {
 			if host := List[goos][goarch]; host != nil {
 				target.CCompiler = host.CCompiler
 				target.CPP = host.CPP
-				if goos == "freebsd" {
+				if goos == FreeBSD {
 					// For some configurations -no-pie is passed to the compiler,
 					// which is not used by clang.
 					// Ensure clang does not complain about it.
@@ -498,18 +522,18 @@ func init() {
 				// In ESA/390 mode, the CPU is able to address only 31bit of memory but
 				// arithmetic operations are still 32bit
 				// Fix cflags by replacing compiler's -m32 option with -m31
-				if goarch == "s390x" {
+				if goarch == S390x {
 					for i := range target.CFlags {
 						target.CFlags[i] = strings.Replace(target.CFlags[i], "-m32", "-m31", -1)
 					}
 				}
 			}
-			if target.PtrSize == 4 && goos == "freebsd" && goarch == "amd64" {
+			if target.PtrSize == 4 && goos == FreeBSD && goarch == AMD64 {
 				// A hack to let 32-bit "test" target tests run on FreeBSD:
 				// freebsd/386 requires a non-default DataOffset to avoid
 				// clobbering mappings created by the C runtime. Since that is the
 				// only target with this constraint, just special-case it for now.
-				target.DataOffset = List[goos]["386"].DataOffset
+				target.DataOffset = List[goos][I386].DataOffset
 			}
 		}
 		target.BuildOS = goos
@@ -524,6 +548,9 @@ func initTarget(target *Target, OS, arch string) {
 	target.initOther = new(sync.Once)
 	target.OS = OS
 	target.Arch = arch
+	if target.KernelArch == "" {
+		target.KernelArch = target.Arch
+	}
 	if target.NeedSyscallDefine == nil {
 		target.NeedSyscallDefine = needSyscallDefine
 	}
@@ -543,7 +570,7 @@ func initTarget(target *Target, OS, arch string) {
 	for i := range target.CFlags {
 		target.replaceSourceDir(&target.CFlags[i], sourceDir)
 	}
-	if OS == "linux" && arch == runtime.GOARCH {
+	if OS == Linux && arch == runtime.GOARCH {
 		// Don't use cross-compiler for native compilation, there are cases when this does not work:
 		// https://github.com/google/syzkaller/pull/619
 		// https://github.com/google/syzkaller/issues/387
@@ -573,8 +600,8 @@ func initTarget(target *Target, OS, arch string) {
 	for _, flags := range [][]string{commonCFlags, target.osCommon.cflags} {
 		target.CFlags = append(target.CFlags, flags...)
 	}
-	if OS == "test" {
-		if runtime.GOARCH != "s390x" {
+	if OS == TestOS {
+		if runtime.GOARCH != S390x {
 			target.LittleEndian = true
 		} else {
 			target.LittleEndian = false
diff --git a/syz-ci/manager.go b/syz-ci/manager.go
index 121169e05..59dc6bf21 100644
--- a/syz-ci/manager.go
+++ b/syz-ci/manager.go
@@ -143,7 +143,8 @@ func (mgr *Manager) loop() {
 	nextBuildTime := time.Now()
 	var managerRestartTime, coverUploadTime time.Time
 	latestInfo := mgr.checkLatest()
-	if latestInfo != nil && time.Since(latestInfo.Time) < kernelRebuildPeriod/2 && mgr.managercfg.TargetOS != "fuchsia" {
+	if latestInfo != nil && time.Since(latestInfo.Time) < kernelRebuildPeriod/2 &&
+		mgr.managercfg.TargetOS != targets.Fuchsia {
 		// If we have a reasonably fresh build,
 		// start manager straight away and don't rebuild kernel for a while.
 		// Fuchsia is a special case: it builds with syz-executor, so if we just updated syzkaller, we need
@@ -410,7 +411,7 @@ func (mgr *Manager) testImage(imageDir string, info *BuildInfo) error {
 		switch err := res.(type) {
 		case *instance.TestError:
 			if rep := err.Report; rep != nil {
-				what := "test"
+				what := targets.TestOS
 				if err.Boot {
 					what = "boot"
 				}
diff --git a/syz-ci/updater.go b/syz-ci/updater.go
index 2463cfa97..795d33151 100644
--- a/syz-ci/updater.go
+++ b/syz-ci/updater.go
@@ -18,6 +18,7 @@ import (
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/pkg/vcs"
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 const (
@@ -232,7 +233,7 @@ func (upd *SyzUpdater) build(commit *vcs.Commit) error {
 		}
 		for _, f := range files {
 			src := filepath.Join(upd.descriptions, f.Name())
-			dst := filepath.Join(upd.syzkallerDir, "sys", "linux", f.Name())
+			dst := filepath.Join(upd.syzkallerDir, "sys", targets.Linux, f.Name())
 			if err := osutil.CopyFile(src, dst); err != nil {
 				return err
 			}
diff --git a/syz-fuzzer/fuzzer_test.go b/syz-fuzzer/fuzzer_test.go
index 04b582622..dae8329f7 100644
--- a/syz-fuzzer/fuzzer_test.go
+++ b/syz-fuzzer/fuzzer_test.go
@@ -11,6 +11,7 @@ import (
 	"github.com/google/syzkaller/pkg/hash"
 	"github.com/google/syzkaller/pkg/signal"
 	"github.com/google/syzkaller/prog"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 type InputTest struct {
@@ -22,7 +23,7 @@ type InputTest struct {
 func TestChooseProgram(t *testing.T) {
 	rs := rand.NewSource(0)
 	r := rand.New(rs)
-	target := getTarget(t, "test", "64")
+	target := getTarget(t, targets.TestOS, targets.TestArch64)
 	fuzzer := &Fuzzer{corpusHashes: make(map[hash.Sig]struct{})}
 
 	const (
@@ -56,7 +57,7 @@ func TestChooseProgram(t *testing.T) {
 }
 
 func TestAddInputConcurrency(t *testing.T) {
-	target := getTarget(t, "test", "64")
+	target := getTarget(t, targets.TestOS, targets.TestArch64)
 	fuzzer := &Fuzzer{corpusHashes: make(map[hash.Sig]struct{})}
 
 	const (
diff --git a/syz-manager/cover.go b/syz-manager/cover.go
index 328f9fbd4..69041fe5b 100644
--- a/syz-manager/cover.go
+++ b/syz-manager/cover.go
@@ -52,7 +52,7 @@ func coverToPCs(target *targets.Target, cov []uint32) []uint64 {
 }
 
 func getVMOffset(target *targets.Target, vmlinux string) (uint32, error) {
-	if target.OS == "freebsd" {
+	if target.OS == targets.FreeBSD {
 		return 0xffffffff, nil
 	}
 	readelf := "readelf"
diff --git a/syz-manager/manager.go b/syz-manager/manager.go
index 05af6d30b..bac2a773a 100644
--- a/syz-manager/manager.go
+++ b/syz-manager/manager.go
@@ -454,7 +454,7 @@ func (mgr *Manager) preloadCorpus() {
 	}
 	mgr.corpusDB = corpusDB
 
-	if seedDir := filepath.Join(mgr.cfg.Syzkaller, "sys", mgr.cfg.TargetOS, "test"); osutil.IsExist(seedDir) {
+	if seedDir := filepath.Join(mgr.cfg.Syzkaller, "sys", mgr.cfg.TargetOS, targets.TestOS); osutil.IsExist(seedDir) {
 		seeds, err := ioutil.ReadDir(seedDir)
 		if err != nil {
 			log.Fatalf("failed to read seeds dir: %v", err)
diff --git a/tools/syz-check/check.go b/tools/syz-check/check.go
index 86048f9a4..de7145dfb 100644
--- a/tools/syz-check/check.go
+++ b/tools/syz-check/check.go
@@ -52,7 +52,7 @@ func main() {
 		flagNetlink = flag.Bool("netlink", true, "do checking of netlink policies")
 	)
 	arches := make(map[string]*string)
-	for arch := range targets.List["linux"] {
+	for arch := range targets.List[targets.Linux] {
 		arches[arch] = flag.String("obj-"+arch, "", arch+" kernel object file")
 	}
 	failf := func(msg string, args ...interface{}) {
@@ -152,7 +152,7 @@ func writeWarnings(OS string, narches int, warnings []Warn) error {
 	byFile := make(map[string][]Warn)
 	for _, warn := range warnings {
 		// KVM is not supported on ARM completely.
-		if OS == "linux" && warn.arch == "arm" && strings.HasSuffix(warn.pos.File, "_kvm.txt") {
+		if OS == targets.Linux && warn.arch == targets.ARM && strings.HasSuffix(warn.pos.File, "_kvm.txt") {
 			continue
 		}
 		byFile[warn.pos.File] = append(byFile[warn.pos.File], warn)
@@ -358,7 +358,7 @@ func parseDescriptions(OS, arch string) ([]prog.Type, map[string]*ast.Struct, []
 // Finally we compare our descriptions with the kernel policy description.
 func checkNetlink(OS, arch, obj string, structTypes []prog.Type,
 	locs map[string]*ast.Struct) ([]Warn, error) {
-	if arch != "amd64" {
+	if arch != targets.AMD64 {
 		// Netlink policies are arch-independent (?),
 		// so no need to check all arches.
 		// Also our definition of nlaPolicy below is 64-bit specific.
diff --git a/tools/syz-imagegen/imagegen.go b/tools/syz-imagegen/imagegen.go
index 033a1dd58..4ca608254 100644
--- a/tools/syz-imagegen/imagegen.go
+++ b/tools/syz-imagegen/imagegen.go
@@ -29,6 +29,7 @@ import (
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // FileSystem represents one file system.
@@ -478,7 +479,7 @@ func main() {
 		}
 		return
 	}
-	target, err := prog.GetTarget("linux", "amd64")
+	target, err := prog.GetTarget(targets.Linux, targets.AMD64)
 	if err != nil {
 		failf("%v", err)
 	}
@@ -587,7 +588,7 @@ func generateImages(target *prog.Target, flagFS string, list bool) ([]*Image, er
 			fmt.Printf("%v [%v images]\n", fs.Name, index)
 			continue
 		}
-		files, err := filepath.Glob(filepath.Join("sys", "linux", "test", "syz_mount_image_"+fs.Name+"_*"))
+		files, err := filepath.Glob(filepath.Join("sys", targets.Linux, "test", "syz_mount_image_"+fs.Name+"_*"))
 		if err != nil {
 			return nil, fmt.Errorf("error reading output dir: %v", err)
 		}
@@ -634,7 +635,8 @@ func (image *Image) generate() error {
 }
 
 func (image *Image) generateSize() error {
-	outFile := filepath.Join("sys", "linux", "test", fmt.Sprintf("syz_mount_image_%v_%v", image.fs.Name, image.index))
+	outFile := filepath.Join("sys", targets.Linux, "test",
+		fmt.Sprintf("syz_mount_image_%v_%v", image.fs.Name, image.index))
 	image.disk = outFile + ".img"
 	f, err := os.Create(image.disk)
 	if err != nil {
diff --git a/tools/syz-kconf/kconf.go b/tools/syz-kconf/kconf.go
index 02ce0e929..841366146 100644
--- a/tools/syz-kconf/kconf.go
+++ b/tools/syz-kconf/kconf.go
@@ -49,7 +49,7 @@ func main() {
 	if *flagSourceDir == "" {
 		failf("missing mandatory flag -sourcedir")
 	}
-	repo, err := vcs.NewRepo("linux", "", *flagSourceDir, vcs.OptPrecious)
+	repo, err := vcs.NewRepo(targets.Linux, "", *flagSourceDir, vcs.OptPrecious)
 	if err != nil {
 		failf("failed to create repo: %v", err)
 	}
@@ -307,12 +307,12 @@ func (ctx *Context) addDependentConfigs(dst *kconfig.ConfigFile, include []strin
 }
 
 func (ctx *Context) setTarget() error {
-	for _, target := range targets.List["linux"] {
+	for _, target := range targets.List[targets.Linux] {
 		if ctx.Inst.Features[target.KernelArch] {
 			if ctx.Target != nil {
 				return fmt.Errorf("arch is set twice")
 			}
-			ctx.Target = targets.GetEx("linux", target.Arch, ctx.Inst.Features[featClang])
+			ctx.Target = targets.GetEx(targets.Linux, target.Arch, ctx.Inst.Features[featClang])
 		}
 	}
 	if ctx.Target == nil {
diff --git a/tools/syz-reprolist/reprolist.go b/tools/syz-reprolist/reprolist.go
index 5c096bfdf..366f82116 100644
--- a/tools/syz-reprolist/reprolist.go
+++ b/tools/syz-reprolist/reprolist.go
@@ -19,6 +19,7 @@ import (
 	"github.com/google/syzkaller/pkg/csource"
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/pkg/vcs"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 var (
@@ -114,7 +115,7 @@ func writeRepros(bugchan chan *dashapi.BugReport) {
 		}
 		log.Printf("%v: %v: C repro", bug.ID, bug.BugStatus)
 		arch := ""
-		if bug.Arch != "" && bug.Arch != "amd64" {
+		if bug.Arch != "" && bug.Arch != targets.AMD64 {
 			arch = fmt.Sprintf(" arch:%v", bug.Arch)
 		}
 		repro := []byte(fmt.Sprintf("// %v\n// %v/bug?id=%v\n// status:%v%v\n",
@@ -173,7 +174,7 @@ func createProg2CArgs(bug *dashapi.BugReport, opts csource.Options, file string)
 	if haveOSFlag {
 		args = append(args, "-os", *flagOS)
 	}
-	if bug.Arch != "" && bug.Arch != "amd64" {
+	if bug.Arch != "" && bug.Arch != targets.AMD64 {
 		args = append(args, "-arch", bug.Arch)
 	}
 	if opts.Fault {
diff --git a/tools/syz-runtest/runtest.go b/tools/syz-runtest/runtest.go
index d961dc867..b6f25d784 100644
--- a/tools/syz-runtest/runtest.go
+++ b/tools/syz-runtest/runtest.go
@@ -116,7 +116,7 @@ func main() {
 		fmt.Printf("%-24v: %v calls enabled\n", sandbox+" sandbox", len(calls))
 	}
 	ctx := &runtest.Context{
-		Dir:          filepath.Join(cfg.Syzkaller, "sys", target.OS, "test"),
+		Dir:          filepath.Join(cfg.Syzkaller, "sys", target.OS, targets.TestOS),
 		Target:       target,
 		Features:     mgr.checkResult.Features,
 		EnabledCalls: enabledCalls,
diff --git a/tools/syz-trace2syz/proggen/fuzz.go b/tools/syz-trace2syz/proggen/fuzz.go
index 7f74534b9..da4fae7bb 100644
--- a/tools/syz-trace2syz/proggen/fuzz.go
+++ b/tools/syz-trace2syz/proggen/fuzz.go
@@ -8,10 +8,11 @@ package proggen
 import (
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys/linux/gen" // pull in the target
+	"github.com/google/syzkaller/sys/targets"
 )
 
 var linuxTarget = func() *prog.Target {
-	target, err := prog.GetTarget("linux", "amd64")
+	target, err := prog.GetTarget(targets.Linux, targets.AMD64)
 	if err != nil {
 		panic(err)
 	}
diff --git a/tools/syz-trace2syz/proggen/proggen_test.go b/tools/syz-trace2syz/proggen/proggen_test.go
index 0eaec0d8d..451147bed 100644
--- a/tools/syz-trace2syz/proggen/proggen_test.go
+++ b/tools/syz-trace2syz/proggen/proggen_test.go
@@ -12,6 +12,7 @@ import (
 
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
+	"github.com/google/syzkaller/sys/targets"
 	"github.com/google/syzkaller/tools/syz-trace2syz/parser"
 )
 
@@ -265,7 +266,7 @@ r0 = openat$rtc(0xffffffffffffff9c, &(0x7f0000000000)='/dev/rtc0\x00', 0x0, 0x0)
 ioctl$RTC_WKALM_SET(r0, 0x4028700f, &(0x7f0000000040)={0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x10000, 0x5181}})`,
 		},
 	}
-	target, err := prog.GetTarget("linux", "amd64")
+	target, err := prog.GetTarget(targets.Linux, targets.AMD64)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/tools/syz-trace2syz/trace2syz.go b/tools/syz-trace2syz/trace2syz.go
index d634f137f..89081d57c 100644
--- a/tools/syz-trace2syz/trace2syz.go
+++ b/tools/syz-trace2syz/trace2syz.go
@@ -22,6 +22,7 @@ import (
 	"github.com/google/syzkaller/pkg/osutil"
 	"github.com/google/syzkaller/prog"
 	_ "github.com/google/syzkaller/sys"
+	"github.com/google/syzkaller/sys/targets"
 	"github.com/google/syzkaller/tools/syz-trace2syz/proggen"
 )
 
@@ -32,8 +33,8 @@ var (
 )
 
 const (
-	goos = "linux" // Target OS
-	arch = "amd64" // Target architecture
+	goos = targets.Linux // Target OS
+	arch = targets.AMD64 // Target architecture
 )
 
 func main() {
diff --git a/vm/gce/gce.go b/vm/gce/gce.go
index 7bc049cb2..e3f23ccee 100644
--- a/vm/gce/gce.go
+++ b/vm/gce/gce.go
@@ -28,6 +28,7 @@ import (
 	"github.com/google/syzkaller/pkg/kd"
 	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 	"github.com/google/syzkaller/vm/vmimpl"
 )
 
@@ -248,7 +249,7 @@ func (inst *instance) Run(timeout time.Duration, stop <-chan bool, command strin
 	}
 	merger := vmimpl.NewOutputMerger(tee)
 	var decoder func(data []byte) (int, int, []byte)
-	if inst.env.OS == "windows" {
+	if inst.env.OS == targets.Windows {
 		decoder = kd.Decode
 	}
 	merger.AddDecoder("console", conRpipe, decoder)
@@ -264,7 +265,7 @@ func (inst *instance) Run(timeout time.Duration, stop <-chan bool, command strin
 		sshRpipe.Close()
 		return nil, nil, err
 	}
-	if inst.env.OS == "linux" {
+	if inst.env.OS == targets.Linux {
 		if inst.sshUser != "root" {
 			command = fmt.Sprintf("sudo bash -c '%v'", command)
 		}
@@ -369,10 +370,10 @@ func waitForConsoleConnect(merger *vmimpl.OutputMerger) error {
 }
 
 func (inst *instance) Diagnose() ([]byte, bool) {
-	if inst.env.OS == "freebsd" {
+	if inst.env.OS == targets.FreeBSD {
 		return vmimpl.DiagnoseFreeBSD(inst.consolew)
 	}
-	if inst.env.OS == "openbsd" {
+	if inst.env.OS == targets.OpenBSD {
 		return vmimpl.DiagnoseOpenBSD(inst.consolew)
 	}
 	return nil, false
diff --git a/vm/qemu/qemu.go b/vm/qemu/qemu.go
index 222dc4d8a..15b8e0854 100644
--- a/vm/qemu/qemu.go
+++ b/vm/qemu/qemu.go
@@ -259,7 +259,7 @@ func ctor(env *vmimpl.Env) (vmimpl.Pool, error) {
 		return nil, err
 	}
 	if env.Image == "9p" {
-		if env.OS != "linux" {
+		if env.OS != targets.Linux {
 			return nil, fmt.Errorf("9p image is supported for linux only")
 		}
 		if cfg.Kernel == "" {
diff --git a/vm/vm_test.go b/vm/vm_test.go
index 8c1f82917..31dd65045 100644
--- a/vm/vm_test.go
+++ b/vm/vm_test.go
@@ -13,6 +13,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/mgrconfig"
 	"github.com/google/syzkaller/pkg/report"
+	"github.com/google/syzkaller/sys/targets"
 	"github.com/google/syzkaller/vm/vmimpl"
 )
 
@@ -340,9 +341,9 @@ func testMonitorExecution(t *testing.T, test *Test) {
 	defer os.RemoveAll(dir)
 	cfg := &mgrconfig.Config{
 		Workdir:      dir,
-		TargetOS:     "linux",
-		TargetArch:   "amd64",
-		TargetVMArch: "amd64",
+		TargetOS:     targets.Linux,
+		TargetArch:   targets.AMD64,
+		TargetVMArch: targets.AMD64,
 		Type:         "test",
 	}
 	pool, err := Create(cfg, false)
diff --git a/vm/vmimpl/util.go b/vm/vmimpl/util.go
index 418ae2d66..47340ccde 100644
--- a/vm/vmimpl/util.go
+++ b/vm/vmimpl/util.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/syzkaller/pkg/log"
 	"github.com/google/syzkaller/pkg/osutil"
+	"github.com/google/syzkaller/sys/targets"
 )
 
 // Sleep for d.
@@ -24,7 +25,7 @@ func SleepInterruptible(d time.Duration) bool {
 
 func WaitForSSH(debug bool, timeout time.Duration, addr, sshKey, sshUser, OS string, port int, stop chan error) error {
 	pwd := "pwd"
-	if OS == "windows" {
+	if OS == targets.Windows {
 		pwd = "dir"
 	}
 	startTime := time.Now()