}

// callMayReturn reports whether the called function may return.
// It is passed to the CFG builder.
func (c *CFGs) callMayReturn(call *ast.CallExpr) (r bool) {
	if id, ok := call.Fun.(*ast.Ident); ok && c.pass.TypesInfo.Uses[id] == panicBuiltin {
		return false // panic never returns
	}

	// Is this a static call? Also includes static functions
	// parameterized by a type. Such functions may or may not

  return std::move(*loader).module();
}

// Renames functions in the stablehlo module to avoid naming conflicts with
// existing functions in the tf module.
// Sets _from_xla_call_module attribute for each stablehlo function.
// Returns the new stablehlo main function's name or error.
//
// If we directly insert stablehlo functions into tf module, MLIR will rename
// the stablehlo functions themselves in the tf module automatically to avoid

 */

#ifdef CUNIT_BUILD_TESTS
void test_cunit_CUError(void);
#endif

/* Internal function - users should not generally call this function */
CU_EXPORT void CU_set_error(CU_ErrorCode error);
/**<
 *  Sets the CUnit framework error code.
 *  This function is used internally by CUnit implementation functions
 *  when an error condition occurs within the framework.  It should

	time

FILENAMES
	testdata/benchmark.go
	testdata/example.go
	testdata/testing.go

FUNCTIONS
	// An internal function but exported because it is cross-package; ...
	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)

	// An internal function but exported because it is cross-package; ...

)

// Important! The public back-and-forth conversion functions for the types in this package
// with SAControllerConfiguration types need to be manually exposed like this in order for
// other packages that reference this package to be able to call these conversion functions
// in an autogenerated manner.
// TODO: Fix the bug in conversion-gen so it automatically discovers these Convert_* functions
// in autogenerated code as well.

// enough stack space for call frames, especially for a chain of
// nosplit functions.
//
// It walks all functions to accumulate the number of bytes they can
// grow the stack by without a split check and checks this against the
// limit.
func (ctxt *Link) doStackCheck() {
	sc := newStackCheck(ctxt, false)

	// limit is number of bytes a splittable function ensures are
	// available on the stack. If any call chain exceeds this

        sourceFilesBaseName: String,
        hashTypeSourceName: java.util.function.Function<String, String>,
        classPath: List<File>,
        classPathDependencies: List<File>,
        apiSpec: java.util.function.Function<String, Boolean>,
        parameterNamesSupplier: java.util.function.Function<String, List<String>?>,
        functionSinceSupplier: java.util.function.Function<String, String?>,
    ) {
        invokeFacadeGenerateFunction(

//
// The -funcs flag specifies a comma-separated list of names of
// additional known formatting functions or methods. (This legacy flag
// is rarely used due to the automatic inference described above.)
//
// If the name contains a period, it must denote a specific function
// using one of the following forms:
//
//	dir/pkg.Function
//	dir/pkg.Type.Method
//	(*dir/pkg.Type).Method
//

constexpr char kInvalidExecutorGraphMsg[] =
    "functions must be of a single Graph with single op Islands: ";

}  // namespace

mlir::LogicalResult VerifyExportSuitable(mlir::ModuleOp module) {
  mlir::WalkResult result = module.walk([&](mlir::func::FuncOp function) {
    if (!llvm::hasSingleElement(function)) {
      function.emitError(kInvalidExecutorGraphMsg)
          << "only single block functions are supported";

  because they have untyped words on the stack.

- Functions that must not be preempted on entry.

- Functions that may run without a valid G. For example, functions
  that run in early runtime start-up, or that may be entered from C
  code such as cgo callbacks or the signal handler.

Splittable functions ensure there's some amount of space on the stack
for nosplit functions to run in and the linker checks that any static