// RUN: tf-tfrt-opt %s -tf-restore-merging | FileCheck %s

// CHECK-LABEL: func @single_restore_group
// CHECK-SAME:    (%[[ARG0:.*]]: {{.*}})
func.func @single_restore_group(%arg0: tensor<!tf_type.string>) -> (tensor<*xf32>, tensor<*xi32>) {
  %0 = "tf.Const"() {value = dense<"foo"> : tensor<1x!tf_type.string>} : () -> tensor<1x!tf_type.string>
  %1 = "tf.Const"() {value = dense<""> : tensor<1x!tf_type.string>} : () -> tensor<1x!tf_type.string>

import org.junit.Test
import spock.lang.Issue


class UnitCodecTest : AbstractUserTypeCodecTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/25560")
    fun `same Unit instance is used upon restore`() {
        configurationCacheRoundtripOf(Unit).run {
            assertThat(this, sameInstance(Unit))
        }
    }

	}()

	finished := false
	start := time.Now()

	// Clean up in a deferred call so we can recover if the example panics.
	defer func() {
		timeSpent := time.Since(start)

		// Close pipe, restore stdout, get output.
		w.Close()
		os.Stdout = stdout
		out := <-outC

		err := recover()
		ok = eg.processRunResult(out, timeSpent, finished, err)
	}()

	// Run example.
	eg.F()
	finished = true

go build -cover -o $WORK/prog.exe .

# Save off old GOCOVERDIR setting
env SAVEGOCOVERDIR=$GOCOVERDIR

mkdir $WORK/covdata
env GOCOVERDIR=$WORK/covdata
exec $WORK/prog.exe

# Restore previous GOCOVERDIR setting
env GOCOVERDIR=$SAVEGOCOVERDIR

# Report percent lines covered.
go tool covdata percent -i=$WORK/covdata
stdout '\s*mainwithtest\s+coverage:'
! stdout 'main\s+coverage:'

// asmcheck

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Make sure this code doesn't generate spill/restore.

package codegen

func pack20(in *[20]uint64) uint64 {
	var out uint64
	out |= 4
	// amd64:-`.*SP.*`
	out |= in[0] << 4
	// amd64:-`.*SP.*`
	out |= in[1] << 7
	// amd64:-`.*SP.*`
	out |= in[2] << 10

            return null; // ignoring file annotation
        }

        restore(startIndex)
        if (let(kotlinGrammar.annotation) is ParserResult.Success<*>) {
            return startIndex.offset until currentPosition.offset
        }

        restore(startIndex)
        advance()

        return null
    }

    KotlinLexer().apply {
        start(script)

		t.Fatal(err)
	}
	if allocation.Range != "rangeSpecValue" {
		t.Errorf("unexpected stored Range: %s", allocation.Range)
	}
	if err := other.Restore("rangeSpecValue", allocation.Data); err != nil {
		t.Fatal(err)
	}
	if !other.Has(2) {
		t.Fatalf("could not restore allocated IP: %#v", other)
	}

	other = allocator.NewAllocationMap(100, "rangeSpecValue")

	MOVW	$0, R8
	MOVW	R8, (R7) // clear g slot

	JMP	finish

nosaveg:
	BL	(R4)

finish:
	MOVW	R5, R13		// Restore real SP
	// Restore vdsoPC, vdsoSP
	// We don't worry about being signaled between the two stores.
	// If we are not in a signal handler, we'll restore vdsoSP to 0,
	// and no one will care about vdsoPC. If we are in a signal handler,
	// we cannot receive another signal.
	MOVW	8(R13), R7

	FLTD	F1, F2, X6;	\
	/* Inf should keep same signed with x then return */;	\
	BEQZ	X6, 3(PC); \
	FCVTLD.MODE	F0, X6;	\
	FCVTDL	X6, F1;		\
	/* rounding will drop signed bit in RISCV, restore it */; \
	FSGNJD	F0, F1, F0;	\
	MOVD	F0, ret+8(FP); 	\
	RET

// func archFloor(x float64) float64
ROUNDFN(·archFloor, RDN)

// func archCeil(x float64) float64
ROUNDFN(·archCeil, RUP)

#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/status.h"

namespace tensorflow {
namespace internal {

// TODO(bmzhao): Add a function to restore multiple tensors in one call.

// Restores a single non-partioned tensorhandle of dtype `dtype`, using
// checkpoint at `prefix`, with a value stored in `checkpoint_key`.