{"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")

  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

    return failure();
  }
  return success();
}

// Check if we can move TPUCopyWithDynamicShapeOp out of a launch. This is the
// case if its results aren't used by other ops except for the return op.
bool CanMove(Operation* op) {
  auto launch_op = llvm::dyn_cast<tf_device::LaunchOp>(op->getParentOp());
  if (!launch_op) return false;
  for (Value result : op->getResults()) {
    for (Operation* user : result.getUsers()) {

	MS_ASYNC                        = 0x2 // asynchronous writes
	MS_INVALIDATE                   = 0x4 // invalidate mappings
	MS_BIND                         = 0x00001000
	MS_MOVE                         = 0x00002000
	MS_NOSUID                       = 0x00000002
	MS_PRIVATE                      = 0x00040000
	MS_REC                          = 0x00004000
	MS_REMOUNT                      = 0x00008000

	MS_MANDLOCK                                 = 0x40
	MS_MGC_MSK                                  = 0xffff0000
	MS_MGC_VAL                                  = 0xc0ed0000
	MS_MOVE                                     = 0x2000
	MS_NOATIME                                  = 0x400
	MS_NODEV                                    = 0x4
	MS_NODIRATIME                               = 0x800