import "unsafe"

type mremapMmapper struct {
	mmapper
	mremap func(oldaddr uintptr, oldlength uintptr, newlength uintptr, flags int, newaddr uintptr) (xaddr uintptr, err error)
}

var mapper = &mremapMmapper{
	mmapper: mmapper{
		active: make(map[*byte][]byte),
		mmap:   mmap,
		munmap: munmap,
	},
	mremap: mremap,
}

func (m *mremapMmapper) Mremap(oldData []byte, newLength int, flags int) (data []byte, err error) {

	f    *os.File
	Data []byte
	// Some windows magic
	Windows interface{}
}

// Mmap maps the given file into memory.
// When remapping a file, pass the most recently returned Data.
func Mmap(f *os.File, data *Data) (Data, error) {
	return mmapFile(f, data)
}

// Munmap unmaps the given file from memory.
func Munmap(d *Data) error {
	// d.f.Close() on Windows still gets an error
	return munmapFile(*d)

import _ "unsafe"

// When using cgo, call the C library for mmap, so that we call into
// any sanitizer interceptors. This supports using the memory
// sanitizer with Go programs. The memory sanitizer only applies to
// C/C++ code; this permits that code to see the Go code as normal
// program addresses that have been initialized.

// To support interceptors that look for both mmap and munmap,
// also call the C library for munmap.

// munmap calls the munmap system call. It is implemented in assembly.

//go:build unix

package ld

import (
	"syscall"
)

// Mmap maps the output file with the given size. It unmaps the old mapping
// if it is already mapped. It also flushes any in-heap data to the new
// mapping.
func (out *OutBuf) Mmap(filesize uint64) (err error) {
	oldlen := len(out.buf)
	if oldlen != 0 {
		out.munmap()
	}

	for {
		if err = out.fallocate(filesize); err != syscall.EINTR {
			break

// license that can be found in the LICENSE file.

//go:build aix || darwin || dragonfly || freebsd || openbsd || solaris || zos

package unix

var mapper = &mmapper{
	active: make(map[*byte][]byte),
	mmap:   mmap,
	munmap: munmap,

	void *p;

	_cgo_tsan_acquire();
	p = mmap(addr, length, prot, flags, fd, offset);
	_cgo_tsan_release();
	if (p == MAP_FAILED) {
		/* This is what the Go code expects on failure.  */
		return (uintptr_t)errno;
	}
	return (uintptr_t)p;
}

void
x_cgo_munmap(void *addr, uintptr_t length) {
	int r;

	_cgo_tsan_acquire();
	r = munmap(addr, length);
	_cgo_tsan_release();
	if (r < 0) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build unix

// Export guts for testing.

package runtime

var Mmap = mmap
var Munmap = munmap

const ENOMEM = _ENOMEM
const MAP_ANON = _MAP_ANON
const MAP_PRIVATE = _MAP_PRIVATE
const MAP_FIXED = _MAP_FIXED

func GetPhysPageSize() uintptr {
	return physPageSize

	data, err := syscall.Mmap(int(f.Fd()), 0, mmapLength, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_SHARED)
	if err != nil {
		return Data{}, &fs.PathError{Op: "mmap", Path: f.Name(), Err: err}
	}
	return Data{f, data[:n], nil}, nil
}

func munmapFile(d Data) error {
	if len(d.Data) == 0 {
		return nil
	}
	err := syscall.Munmap(d.Data)
	if err != nil {

// sysMunmap calls the munmap system call. It is implemented in assembly.
func sysMunmap(addr unsafe.Pointer, n uintptr)

// callCgoMunmap calls the munmap function in the runtime/cgo package
// using the GCC calling convention. It is implemented in assembly.