}

//go:nosplit
func validSIGPROF(mp *m, c *sigctxt) bool {
	return true
}

func sysargs(argc int32, argv **byte) {
	n := argc + 1

	// skip over argv, envp to get to auxv
	for argv_index(argv, n) != nil {
		n++
	}

	// skip NULL separator
	n++

	auxvp := (*[1 << 28]uintptr)(add(unsafe.Pointer(argv), uintptr(n)*goarch.PtrSize))
	pairs := sysauxv(auxvp[:])

    mlir::func::FuncOp func, llvm::function_ref<void(int arg_index)> action) {
  for (int arg_index = 0; arg_index < func.getNumArguments(); ++arg_index) {
    if (IsArgConsumedByFallback(func, arg_index)) action(arg_index);
  }
}

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,
    llvm::function_ref<void(llvm::StringRef func_name, int arg_index)> action) {
  for (auto func : module.getOps<mlir::func::FuncOp>()) {

namespace tfrt {
namespace fallback_async {

bool IsArgConsumedByFallback(mlir::func::FuncOp func, int arg_index);

void ForEachArgConsumedByFallback(
    mlir::func::FuncOp func, llvm::function_ref<void(int arg_index)> action);

void ForEachArgConsumedByFallback(
    mlir::ModuleOp module,
    llvm::function_ref<void(llvm::StringRef func_name, int arg_index)> action);

}  // namespace fallback_async
}  // namespace tfrt

Operation *LookupBoundInput(func::FuncOp func, int arg_index,
                            const SymbolTable &symbol_table);

template <typename T>
T LookupBoundInputOfType(func::FuncOp func, int arg_index,
                         const SymbolTable &symbol_table) {
  return llvm::dyn_cast_or_null<T>(
      LookupBoundInput(func, arg_index, symbol_table));
}

  ASSERT_TRUE(module);

  std::vector<std::pair<std::string, int>> func_and_index;
  ForEachArgConsumedByFallback(
      module.get(),
      [&func_and_index](llvm::StringRef func_name, int arg_index) {
        func_and_index.push_back({func_name.str(), arg_index});
      });

  ASSERT_EQ(func_and_index.size(), 1);
  EXPECT_EQ(func_and_index[0].first, "test");
  EXPECT_EQ(func_and_index[0].second, 2);
}

}  // namespace

        result.addStatement("boolean $L = true", varargMatched);
        result.beginControlFlow("for (int argIndex = $1L; argIndex < invocation.getArgsCount(); argIndex++)", paramIndex);

        CodeBlock nextArg = CodeBlock.of("nextArg");
        result.addStatement("Object $L = invocation.getArgument(argIndex)", nextArg);
        result.beginControlFlow("if ($1L == null || $1L instanceof $2T)", nextArg, entryParamType);

		sep = ", "
		buf.WriteString(text)
	}
	return buf.String()
}

func gnuArg(inst *Inst, argIndex int, arg Arg) string {
	switch inst.Op &^ 15 {
	case LDRD_EQ, LDREXD_EQ, STRD_EQ:
		if argIndex == 1 {
			// second argument in consecutive pair not printed
			return ""
		}
	case STREXD_EQ:
		if argIndex == 2 {
			// second argument in consecutive pair not printed
			return ""
		}
	}

    if (index < 0) {
      return emitOpError() << "variable_arg_indices must be positive";
    }

    if (index <= prev_index) {
      return emitOpError()
             << "variable_arg_indices must be sorted in ascending order";
    }
    prev_index = index;
  }

  return mlir::success();
}

}  // namespace TF
}  // namespace mlir

// A global tensor is bound to arguments of multiple funcs.
// This struct tracks which funcs (and which argument to that func) the global
// tensor is bound to.
struct GlobalTensorUse {
  mutable func::FuncOp func;
  size_t arg_index;
};

using GlobalTensorUsesMap =
    std::map<GlobalTensorOp, std::vector<GlobalTensorUse>>;

bool IsImmutable(GlobalTensorOp global_tensor,
                 ArrayRef<GlobalTensorUse> global_tensor_uses,

        result.addStatement("boolean $L = true", varargMatched);
        result.beginControlFlow("for (int argIndex = $1L; argIndex < argumentClasses.length; argIndex++)", paramIndex);
        CodeBlock nextArg = CodeBlock.of("nextArg");
        result.addStatement("Class<?> $L = argumentClasses[argIndex]", nextArg);
        result.beginControlFlow("if ($2L != null && !$1T.class.isAssignableFrom($2L))", entryParamType, nextArg);