// dependencies.
//
// The -fuzzcache flag causes clean to remove files stored in the Go build
// cache for fuzz testing. The fuzzing engine caches files that expand
// code coverage, so removing them may make fuzzing less effective until
// new inputs are found that provide the same coverage. These files are
// distinct from those stored in testdata directory; clean does not remove
// those files.
//

func FindVendor(path string) (index int, ok bool) {
	// Two cases, depending on internal at start of string or not.
	// The order matters: we must return the index of the final element,
	// because the final one is where the effective import path starts.
	switch {
	case strings.Contains(path, "/vendor/"):
		return strings.LastIndex(path, "/vendor/") + 1, true
	case strings.HasPrefix(path, "vendor/"):
		return 0, true
	}

		// MOVxload: loads
		// Load (Q=8,L=4,W=2,B=1) bytes from (arg0+auxint+aux), arg1=mem.
		// "+auxint+aux" == add auxint and the offset of the symbol in aux (if any) to the effective address
		// Standard versions zero extend the result. SX versions sign extend the result.
		{name: "MOVBload", argLength: 2, reg: gpload, asm: "MOVBLZX", aux: "SymOff", typ: "UInt8", faultOnNilArg0: true, symEffect: "Read"},

  }
  // Recall those inputs to the concat op that are not produced by a binary op
  // of the `first_arg_op` kind (e.g. tf.Mul) are stored in `exceptions`. If
  // there are too many exceptions, it might not be cost effective to apply the
  // concat hoisting optimization here.
  // Setting the threshold to be 50% as a simple cost model heuristic. e.g. If 1
  // out of 2 concat inputs is an exception, we don't apply the hoist. If it's 1

          {static_cast<int>(return_squeeze_shape.size())},
          mlir::IntegerType::get(value_tensor.getContext(), 32)),
      llvm::ArrayRef(return_squeeze_shape));
}

// This is a utility function to deduce the effective permutation to apply on
// TFL_TransposeOp when the tensor has some dimensions with value==1
// Example- "tfl.transpose"(tensor<56x8x56x1x1x1x7xf32>, [4, 5, 1, 2, 0, 6, 3])

  PredOpTrait<"operand " # n # " is at most " # m # "-D",
    TFL_OperandHasRankAtMostPred<n, m>>;

// Not all dimentions in the tensor will contribute to the data move in a
// TransposeOp. Effective rank is the number of dimentions != 1
class TFL_TransposeOperandHasEffectiveRankAtMost<int n, int m> :
  PredOpTrait<"operand " # n # " is at most " # m # "-D",
    Or<[TFL_OperandIsUnrankedPred<n>,

	{AMOVD, C_AACON, C_NONE, C_NONE, C_RSP, C_NONE, 4, 4, REGFROM, 0, 0},
	{AMOVD, C_AACON2, C_NONE, C_NONE, C_RSP, C_NONE, 4, 8, REGFROM, NOTUSETMP, 0},

	/* load long effective stack address (load int32 offset and add) */
	{AMOVD, C_LACON, C_NONE, C_NONE, C_RSP, C_NONE, 34, 8, REGSP, LFROM, 0},

	// Load a large constant into a vector register.

  }
  func.return
  // expected-remark@above {{ID: 13}}
  // expected-remark@above {{Sinks: {12}}}
}

// -----

// Tests that the pass tracks control dependencies for side-effecting on unknown
// resources.

// CHECK-LABEL: func @unknown_side_effecting_op
func.func @unknown_side_effecting_op(%arg0: tensor<32xf32>) -> () {
// expected-remark@above {{ID: 14}}
  tf_executor.graph {

 * credentials were used (e.g. some IPC$ services).
 */

    public Principal getPrincipal() {
        return auth;
    }

/**
 * Returns the last component of the target URL. This will
 * effectively be the name of the file or directory represented by this
 * <code>SmbFile</code> or in the case of URLs that only specify a server
 * or workgroup, the server or workgroup will be returned. The name of

  // Tests extraction of a single outside compiled cluster inside a tf.IfRegion
  // op. Check that we mark the rewritten control-flow as stateful even though
  // the original control-flow is not (this is due to added side-effecting
  // communication ops).

  // CHECK-LABEL: func @outside_compiled_ops_inside_tf_if
  func.func @outside_compiled_ops_inside_tf_if(%arg0: tensor<2xi32>) -> tensor<2xi32> {