//go:linkname msanmalloc
//go:noescape
func msanmalloc(addr unsafe.Pointer, sz uintptr)

//go:linkname msanfree
//go:noescape
func msanfree(addr unsafe.Pointer, sz uintptr)

//go:linkname msanmove
//go:noescape
func msanmove(dst, src unsafe.Pointer, sz uintptr)

// These are called from msan_GOARCH.s
//
//go:cgo_import_static __msan_read_go
//go:cgo_import_static __msan_write_go
//go:cgo_import_static __msan_malloc_go

//go:linkname Malloc runtime.msanmalloc
func Malloc(addr unsafe.Pointer, sz uintptr)

//go:linkname Free runtime.msanfree
func Free(addr unsafe.Pointer, sz uintptr)

//go:linkname Move runtime.msanmove

func msanwrite(addr unsafe.Pointer, sz uintptr)    { throw("msan") }
func msanmalloc(addr unsafe.Pointer, sz uintptr)   { throw("msan") }
func msanfree(addr unsafe.Pointer, sz uintptr)     { throw("msan") }

	GCWriteBarrier    [8]*obj.LSym
	Goschedguarded    *obj.LSym
	Growslice         *obj.LSym
	InterfaceSwitch   *obj.LSym
	Memmove           *obj.LSym
	Msanread          *obj.LSym
	Msanwrite         *obj.LSym
	Msanmove          *obj.LSym
	Newobject         *obj.LSym
	Newproc           *obj.LSym
	Panicdivide       *obj.LSym
	Panicshift        *obj.LSym
	PanicdottypeE     *obj.LSym
	PanicdottypeI     *obj.LSym

	{"runtime.racefuncexit", 1},
	{"runtime.raceread", 1},
	{"runtime.racewrite", 1},
	{"runtime.racereadrange", 1},
	{"runtime.racewriterange", 1},
	{"runtime.msanread", 1},
	{"runtime.msanwrite", 1},
	{"runtime.msanmove", 1},
	{"runtime.asanread", 1},
	{"runtime.asanwrite", 1},
	{"runtime.checkptrAlignment", 1},
	{"runtime.checkptrArithmetic", 1},
	{"runtime.libfuzzerTraceCmp1", 1},
	{"runtime.libfuzzerTraceCmp2", 1},

func racewrite(uintptr)
func racereadrange(addr, size uintptr)
func racewriterange(addr, size uintptr)

// memory sanitizer
func msanread(addr, size uintptr)
func msanwrite(addr, size uintptr)
func msanmove(dst, src, size uintptr)

// address sanitizer
func asanread(addr, size uintptr)
func asanwrite(addr, size uintptr)

func checkptrAlignment(unsafe.Pointer, *byte, uintptr)

	{"raceread", funcTag, 31},
	{"racewrite", funcTag, 31},
	{"racereadrange", funcTag, 144},
	{"racewriterange", funcTag, 144},
	{"msanread", funcTag, 144},
	{"msanwrite", funcTag, 144},
	{"msanmove", funcTag, 145},
	{"asanread", funcTag, 144},
	{"asanwrite", funcTag, 144},
	{"checkptrAlignment", funcTag, 146},
	{"checkptrArithmetic", funcTag, 148},
	{"libfuzzerTraceCmp1", funcTag, 149},

	ir.Syms.Memmove = typecheck.LookupRuntimeFunc("memmove")
	ir.Syms.Msanread = typecheck.LookupRuntimeFunc("msanread")
	ir.Syms.Msanwrite = typecheck.LookupRuntimeFunc("msanwrite")
	ir.Syms.Msanmove = typecheck.LookupRuntimeFunc("msanmove")
	ir.Syms.Asanread = typecheck.LookupRuntimeFunc("asanread")
	ir.Syms.Asanwrite = typecheck.LookupRuntimeFunc("asanwrite")
	ir.Syms.Newobject = typecheck.LookupRuntimeFunc("newobject")

		// Too many values live across blocks can cause pathological
		// behavior in the register allocator (see issue 52180).
		return
	}

	canMove := f.Cache.allocBoolSlice(f.NumValues())
	defer f.Cache.freeBoolSlice(canMove)

	// Compute the memory states of each block.
	startMem := f.Cache.allocValueSlice(f.NumBlocks())
	defer f.Cache.freeValueSlice(startMem)

  if (Type() == DT_STRING && NumElements() > 0) {
    TF_TString* data = static_cast<TF_TString*>(Data());
    if (CanMove() && data != nullptr) {
      for (int64_t i = 0; i < NumElements(); ++i) {
        TF_TString_Dealloc(&data[i]);
      }
    }
  }
  delete this;
}

bool TensorInterface::CanMove() const {
  // It is safe to move the Tensor if and only if we own the unique reference to