Valu("rstore", OpStore, types.TypeMem, 0, c.config.Types.Int64, "raddr", "r10", "raddrdef"),
			Goto("exit")),
		Bloc("exit",
			Exit("rstore")))

	CheckFunc(fun.f)
	cse(fun.f)
	deadcode(fun.f)
	CheckFunc(fun.f)

	s1Cnt := 2
	// r1 == r2 == r3, needs to remove two of this set
	s2Cnt := 1
	// r4 == r5, needs to remove one of these
	for k, v := range fun.values {
		if v.Op == OpInvalid {

// function for values with zero arguments to allow the more expensive cse
// to begin with a reduced number of values. Values are just relinked,
// nothing is deleted. A subsequent deadcode pass is required to actually
// remove duplicate expressions.
func zcse(f *Func) {
	vals := make(map[vkey]*Value)

	for _, b := range f.Blocks {
		for i := 0; i < len(b.Values); i++ {
			v := b.Values[i]

	}
	slurp, err := os.ReadFile(filepath.Join(td, "x.exe"))
	if err != nil {
		t.Fatal(err)
	}
	if bytes.Contains(slurp, []byte("THIS SHOULD BE ELIMINATED")) {
		t.Error("binary contains code that should be deadcode eliminated")
	}

}

// -----

module attributes {tf_saved_model.semantics} {
  // expected-error@+1 {{no predecessor}}
  func.func @f() -> () attributes {tf_saved_model.exported_names = ["f"]} {
  ^entry():
    return
  ^deadcode(%0: tensor<!tf_type.resource<tensor<?xf32>>>):
    %ret = "tf.ReadVariableOp"(%0) : (tensor<!tf_type.resource<tensor<?xf32>>>) -> tensor<?xf32>
    return
  }
}

// -----

			[]string{"main.large"}},
	}
	for _, test := range tests {
		test := test
		t.Run(test.src, func(t *testing.T) {
			t.Parallel()
			src := filepath.Join("testdata", "deadcode", test.src+".go")
			exe := filepath.Join(tmpdir, test.src+".exe")
			cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-ldflags=-dumpdep", "-o", exe, src)
			out, err := cmd.CombinedOutput()
			if err != nil {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ld

import "cmd/link/internal/loader"

// Min-heap implementation, for the deadcode pass.
// Specialized for loader.Sym elements.

type heap []loader.Sym

func (h *heap) push(s loader.Sym) {
	*h = append(*h, s)
	// sift up
	n := len(*h) - 1
	for n > 0 {
		p := (n - 1) / 2 // parent

    --- PASS: TestVet/1 (0.07s)
        vet_test.go:114: files: ["testdata/atomic.go" "testdata/lostcancel.go" "testdata/unsafeptr.go"]
    --- PASS: TestVet/7 (0.19s)
        vet_test.go:114: files: ["testdata/deadcode.go" "testdata/shift.go"]
--- PASS: TestVetDirs (0.01s)
    --- PASS: TestVetDirs/testingpkg (0.06s)
    --- PASS: TestVetDirs/divergent (0.05s)
    --- PASS: TestVetDirs/buildtag (0.06s)

// license that can be found in the LICENSE file.

package ssa

// combine copyelim and phielim into a single pass.
// copyelim removes all uses of OpCopy values from f.
// A subsequent deadcode pass is needed to actually remove the copies.
func copyelim(f *Func) {
	phielim(f)

	// loop of copyelimValue(v) process has been done in phielim() pass.
	// Update block control values.
	for _, b := range f.Blocks {

    --- PASS: Test☺☹/1 (0.07s)
        vet_test.go:114: φιλεσ: ["testdata/atomic.go" "testdata/lostcancel.go" "testdata/unsafeptr.go"]
    --- PASS: Test☺☹/7 (0.19s)
        vet_test.go:114: φιλεσ: ["testdata/deadcode.go" "testdata/shift.go"]
--- PASS: Test☺☹Dirs (0.01s)
    --- PASS: Test☺☹Dirs/testingpkg (0.06s)
    --- PASS: Test☺☹Dirs/divergent (0.05s)
    --- PASS: Test☺☹Dirs/buildtag (0.06s)

		addlibpath(ctxt, "command line", "command line", flag.Arg(0), "main", "", zerofp)
	}
	bench.Start("loadlib")
	ctxt.loadlib()

	bench.Start("inittasks")
	ctxt.inittasks()

	bench.Start("deadcode")
	deadcode(ctxt)

	bench.Start("linksetup")
	ctxt.linksetup()

	bench.Start("dostrdata")
	ctxt.dostrdata()
	if buildcfg.Experiment.FieldTrack {
		bench.Start("fieldtrack")