// Experimental heap span events. IDs map reversibly to base addresses.
	traceEvSpan      // heap span exists [timestamp, id, npages, type/class]
	traceEvSpanAlloc // heap span alloc [timestamp, id, npages, type/class]
	traceEvSpanFree  // heap span free [timestamp, id]

	// Experimental heap object events. IDs map reversibly to addresses.
	traceEvHeapObject      // heap object exists [timestamp, id, type]

package ld

// Mmap allocates an in-heap output buffer with the given size. It copies
// any old data (if any) to the new buffer.
func (out *OutBuf) Mmap(filesize uint64) error {
	// We need space to put all the symbols before we apply relocations.
	oldheap := out.heap
	if filesize < uint64(len(oldheap)) {
		panic("mmap size too small")
	}
	out.heap = make([]byte, filesize)
	copy(out.heap, oldheap)
	return nil
}

type StkObj struct {
	h *HeapObj
}

var n int
var c int = -1

func gc() {
	// encourage heap object to be collected, and have its finalizer run.
	runtime.GC()
	runtime.GC()
	runtime.GC()
	n++
}

func main() {
	f()
	gc() // prior to stack objects, heap object is not collected until here
	if c < 0 {
		panic("heap object never collected")
	}
	if c != 1 {

// #cgo noescape annotations for a C function means its arguments won't escape to heap.

// We assume that there won't be 100 new allocated heap objects in other places,
// i.e. runtime.ReadMemStats or other runtime background works.
// So, the tests are:
// 1. at least 100 new allocated heap objects after invoking withoutNoEscape 100 times.
// 2. less than 100 new allocated heap objects after invoking withoutNoEscape 100 times.

/*

import org.gradle.internal.jvm.Jvm;

import java.util.Arrays;
import java.util.Locale;

/**
 * Helper to compute maximum heap sizes.
 */
public class MaximumHeapHelper {

    /**
     * Get the default maximum heap.
     *
     * Different JVMs on different systems may use a different default for maximum heap when unset.
     * This method implements a best effort approximation, omitting rules for low memory systems (<192MB total RAM).

}

func F4(b *B) { // ERROR "leaking param content: b"
	fmt.Println(*b) // ERROR "\.\.\. argument does not escape" "\*b escapes to heap"
}

func F4a(b *B) { // ERROR "leaking param content: b" "mutates param: b derefs=0"
	b.x = 2
	fmt.Println(*b) // ERROR "\.\.\. argument does not escape" "\*b escapes to heap"
}

func F5(b *B) { // ERROR "leaking param: b"
	sink = b
}

REM FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -Djavax.net.ssl.trustStorePassword=changeit

REM Causes the JVM to dump its heap on OutOfMemory.
REM set FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:+HeapDumpOnOutOfMemoryError
REM The path to the heap dump location, note directory must exists and have enough
REM space for a full heap dump.
REM FESS_JAVA_OPTS=%FESS_JAVA_OPTS% -XX:HeapDumpPath=%FESS_HOME%/logs/heapdump.hprof

REM Disables explicit GC

import "unsafe"

// NoEscape hides the pointer p from escape analysis, preventing it
// from escaping to the heap. It compiles down to nothing.
//
// WARNING: This is very subtle to use correctly. The caller must
// ensure that it's truly safe for p to not escape to the heap by
// maintaining runtime pointer invariants (for example, that globals
// and the heap may not generally point into a stack).
//
//go:nosplit
//go:nocheckptr

     * @param heapSize The minimum heap size. Use null for the default minimum heap size.
     */
    void setMinHeapSize(@Nullable String heapSize);

    /**
     * Returns the maximum heap size for the process, if any.
     *
     * @return The maximum heap size. Returns null if the default maximum heap size should be used.
     */
    @Nullable @Optional @Input
    String getMaxHeapSize();

    /**

	for i := 0; i < 10; i++ {
		verifyGCInfo(t, "heap Ptr", runtime.Escape(new(Ptr)), trimDead(infoPtr))
		verifyGCInfo(t, "heap PtrSlice", runtime.Escape(&make([]*byte, 10)[0]), trimDead(infoPtr10))
		verifyGCInfo(t, "heap ScalarPtr", runtime.Escape(new(ScalarPtr)), trimDead(infoScalarPtr))
		verifyGCInfo(t, "heap ScalarPtrSlice", runtime.Escape(&make([]ScalarPtr, 4)[0]), trimDead(infoScalarPtr4))