const string file_name = absl::Substitute("api_def_$0.pbtxt", op.name());
      const string file_path = io::JoinPath(dir, file_name);
      if (env_->FileExists(file_path).ok()) {
        TF_CHECK_OK(api_def_map_->LoadFile(env_, file_path)) << file_path;
      } else {
        // API defs are currently used for only optional pieces.
      }
    }
  }

  }

  DialectRegistry registry_;
  MLIRContext context_;
  OwningOpRef<mlir::ModuleOp> mlir_module_;
  Env* env_;
  std::string test_dir_;
  std::string test_group_name_;
};

TEST_F(LoggingHooksTest, DumpsPassData) {
  std::vector<std::string> files;
  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());

  TF_ASSERT_OK(CreateMlirModule("dead_const.mlir"));

	contextMu    sync.Mutex
	contextNames sets.String

	suiteLabels label.Set

	dumpCount *atomic.Uint64

	traceContext context.Context
	traces       sync.Map
}

func newSuiteContext(s *resource.Settings, envFn resource.EnvironmentFactory, labels label.Set) (*suiteContext, error) {
	scopeID := fmt.Sprintf("[suite(%s)]", s.TestID)

	workDir := path.Join(s.RunDir(), "_suite_context")

  const std::vector<OpSpec>& GetModelOps() const;

 private:
  void InitializeOpApi();
  void BuildModel();

  // Data model: Ops to generate
  std::vector<OpSpec> operators_;

  // Configuration
  Env* env_;
  PathConfig path_config_;

  // Initialized TensorFlow Op/API definitions
  OpList op_list_;
  ApiDefMap* api_def_map_;
};

}  // namespace generator
}  // namespace tensorflow

	CALL	_rt0_386_lib(SB)
	POPL	AX
	POPL	AX
	RET

DATA _rt0_386_android_argv+0x00(SB)/4,$_rt0_386_android_argv0(SB)
DATA _rt0_386_android_argv+0x04(SB)/4,$0  // argv terminate
DATA _rt0_386_android_argv+0x08(SB)/4,$0  // envp terminate
DATA _rt0_386_android_argv+0x0c(SB)/4,$0  // auxv terminate
GLOBL _rt0_386_android_argv(SB),NOPTR,$0x10

// TODO: wire up necessary VDSO (see os_linux_386.go)

DATA _rt0_386_android_argv0(SB)/8, $"gojni"

	val, err = syscall2(&libc_dup2, old, new)
	return
}

//go:linkname syscall_execve syscall.execve
//go:nosplit
func syscall_execve(path, argv, envp uintptr) (err uintptr) {
	_, err = syscall3(&libc_execve, path, argv, envp)
	return
}

// like exit, but must not split stack, for fork.
//
//go:linkname syscall_exit syscall.exit
//go:nosplit
func syscall_exit(code uintptr) {

    def "can relocate Windows specific _wmain symbol"() {
        makeSingleProject()
        file("src/main/cpp/main.cpp") << """
            #include <iostream>

            int wmain(int argc, wchar_t *argv[], wchar_t *envp[] ) {
                std::cout << "hello world!" << std::endl;
                return 0;
            }
        """

        when:
        succeeds("unexport")
        then:

	// sequence of string pointers followed by a NULL, and auxv.
	// The TLS pointer should be initialized to 0.
	//
	// In an ELFv2 compliant dynamically linked binary, R3 contains argc,
	// R4 contains argv, R5 contains envp, R6 contains auxv, and R13
	// contains the TLS pointer.
	//
	// When loading via glibc, the first doubleword on the stack points
	// to NULL a value. (that is *(uintptr)(R1) == 0). This is used to

//sys	getcwd(buf []byte) (n int, err error)
//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error)
//sysnb fork() (pid int, err error)
//sysnb execve(path *byte, argv **byte, envp **byte) (err error)
//sysnb exit(res int) (err error)
//sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
//sysnb getentropy(p []byte) (err error)

	SYS_READLINK             = 58  // { ssize_t|sys||readlink(const char *path, char *buf, size_t count); }
	SYS_EXECVE               = 59  // { int|sys||execve(const char *path, char * const *argp, char * const *envp); }
	SYS_UMASK                = 60  // { mode_t|sys||umask(mode_t newmask); }
	SYS_CHROOT               = 61  // { int|sys||chroot(const char *path); }
	SYS_VFORK                = 66  // { int|sys||vfork(void); }