// Explicitly check that the TensorFlow dialect can constant fold ops.
  // Constant folding is essential for the bridge. Without this check, the
  // bridge may fail with an error that is difficult to understand and not
  // actionable.
  if (!mlir::TF::TensorFlowDialect::HasConstantFoldHook()) {
    return tensorflow::errors::Internal(
        "TensorFlow dialect missing constant fold hook in TFXLA bridge phase "

	if err != nil {
		t.Fatal(err)
	}

	cmd := exec.Command(exe)
	cmd.Env = append(cmd.Environ(), "TEST_TIMEOUT_HANG=1")

	// Hold stdin open until this (parent) process exits.
	if _, err := cmd.StdinPipe(); err != nil {
		t.Fatal(err)
	}

	// Forward stderr to the subprocess so that it can hold the stream open.
	cmd.Stderr = os.Stderr

	if err := cmd.Start(); err != nil {
		t.Fatal(err)
	}
	t.Logf("started %v", cmd)

{% if sponsors %}

{% if sponsors.gold %}

### Gold Sponsors

{% for sponsor in sponsors.gold -%}
<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
{% endfor %}
{% endif %}

// and return value register on the current architecture.
//
// Assembly code knows the layout of the first two fields
// of RegArgs.
//
// RegArgs also contains additional space to hold pointers
// when it may not be safe to keep them only in the integer
// register space otherwise.
type RegArgs struct {
	// Values in these slots should be precisely the bit-by-bit

	if always {
		x = uintptr(unsafe.Pointer(a))
	} else {
		x = 0
	}
	// Clobber the global pointer. The only live ref
	// to the allocated object is now x.
	a = nil

	// Convert to pointer so it should hold
	// the object live across GC call.
	p := unsafe.Pointer(x)

	// Call gc.
	runtime.GC()

	// Convert back to uintptr.
	y := uintptr(p)

	// Mess with y so that the subsequent cast

        "raise-custom-ops.mlir": "medium",
    },
    tags_override = {
        "legalize-tf.mlir": ["no_rocm"],
        "optimize.mlir": ["no_rocm"],
        "prepare-tf.mlir": ["no_rocm"],
        "const-fold.mlir": ["no_mac_arm64"],
    },
    test_file_exts = ["mlir"],
)

# Bundle together all of the test utilities that are used by tests.
filegroup(
    name = "test_utilities",
    testonly = True,
    data = [

			t.Parallel()
			ws := &workerServer{
				fuzzFn: func(e CorpusEntry) (time.Duration, error) {
					return time.Second, tc.fn(e)
				},
			}
			mem := &sharedMem{region: make([]byte, 100)} // big enough to hold value and header
			vals := tc.input
			success, err := ws.minimizeInput(context.Background(), vals, mem, minimizeArgs{})
			if !success {
				t.Errorf("minimizeInput did not succeed")
			}
			if err == nil {

                styled = previous.styledOutput
            }
            if (attribute != null && previousAttribute == null) {
                styled += "{bold-on}"
            }
            if (attribute == null && previousAttribute != null) {
                styled += "{bold-off}"
            }
            if (color != null && color != previousColor) {
                styled += "{foreground-color " + color.name().toLowerCase() + "}"

                start {
                    seen << store.getSchema(SimpleManagedType)
                }
            }
        }

        then:
        seen.size() == 1
    }

    def "does not hold strong reference"() {
        given:
        def cl = new GroovyClassLoader(getClass().classLoader)
        addClass(cl, impl)

        expect:
        store.cache.size() > 0

        when:

	case 'O':
		rst.advance(1)
		rst.writeString("*mut ")
		rst.demangleType()
	case 'F':
		rst.advance(1)
		hold := rst.lifetimes
		rst.fnSig()
		rst.lifetimes = hold
	case 'D':
		rst.advance(1)
		hold := rst.lifetimes
		rst.dynBounds()
		rst.lifetimes = hold
		if len(rst.str) == 0 || rst.str[0] != 'L' {
			rst.fail("expected L")
		}
		rst.advance(1)