package main

type pa []int

type p int

func (this *pa) func1() (v *p, c int) {
	for _ = range *this {
		c++
	}
	v = (*p)(&c)
	return
}

func (this *pa) func2() p {
	return (*p).func3(this.func1())
}

func (this *p) func3(f int) p {
	return *this
}

func (this *pa) func2dots() p {
	return (*p).func3(this.func1())
}

func (this *p) func3dots(f ...int) p {
	return *this
}

        file("src/main/headers/funcs.h") << """
            int func1();
            int func2();
"""
        file("src/main/cpp/main.cpp") << """
            #include <iostream>
            #include "funcs.h"
            int main () {
                std::cout << func1() << func2() << std::endl;
                return 0;
            }
"""
        file("src/main/cpp1/func1.cpp") << """
            int getOne();

func f1() {
	p = alloc(2) // ERROR "inlining call to alloc" "moved to heap: x"

	// Escape analysis used to miss inlined code in closures.

	func() { // ERROR "can inline f1.func1"
		p = alloc(3) // ERROR "inlining call to alloc"
	}() // ERROR "inlining call to f1.func1" "inlining call to alloc" "moved to heap: x"

	f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"

# assembly 2^26 or so times.
#
# We build something which should be laid out as such:
#
# bar.Bar
# main.Func1
# bar.Bar+400-tramp0
# main.BigAsm
# main.Func2
# bar.Bar+400-tramp1
#
# bar.Bar needs to be placed far enough away to generate relocations
# from main package calls. and main.Func1 and main.Func2 are placed
# a bit more than the direct call limit apart, but not more than 0x400

package p

func f(x int) func(int) int {
	return func(y int) int { return x + y } // ERROR "heap-allocated closure f\.func1, not allowed in runtime"
}

func g(x int) func(int) int { // ERROR "x escapes to heap, not allowed in runtime"
	return func(y int) int { // ERROR "heap-allocated closure g\.func1, not allowed in runtime"
		x += y
		return x + y
	}

	}
	// Only frames in the test package are checked.
	want := []string{
		"test._Cfunc_backtrace",
		"test.testCallbackCallersSEH.func1.1",
		"test.testCallbackCallersSEH.func1",
		"test.goCallback",
		"test._Cfunc_callback",
		"test.nestedCall.func1",
		"test.nestedCall",
		"test.testCallbackCallersSEH",
		"test.TestCallbackCallersSEH",
	}
	pc := make([]uintptr, 100)
	n := 0
	nestedCall(func() {

	if runtime.GOARCH != "amd64" {
		t.Skip("skipping amd64-only test")
	}
	want := []string{"runtime_test.sehCallers", "runtime_test.TestSehUnwindDoublePanic.func1.1", "runtime.gopanic",
		"runtime_test.TestSehUnwindDoublePanic.func1", "runtime.gopanic", "runtime_test.TestSehUnwindDoublePanic"}
	defer func() {
		defer func() {
			if recover() == nil {
				t.Fatal("did not panic")
			}
			pcs := sehCallers()

		},
		// ExerciseFuncClosure
		// TODO(prattmic): Closure callees not implemented.
		//{
		//	pos:    "./devirt.go:249:27",
		//	callee: "AddClosure.func1",
		//},
		//{
		//	pos:    "./devirt.go:249:15",
		//	callee: "mult.MultClosure.func1",
		//},
	}

	testPGODevirtualize(t, dir, want, profFileName)
}

// TestPGOPreprocessDevirtualize tests that specific functions are devirtualized when PGO

23 101
example.com/pgo/devirtualize.ExerciseFuncField
example.com/pgo/devirtualize/mult%2epkg.MultFn
23 94
example.com/pgo/devirtualize.ExerciseFuncClosure
example.com/pgo/devirtualize/mult%2epkg.MultClosure.func1
18 93
example.com/pgo/devirtualize.ExerciseFuncClosure
example.com/pgo/devirtualize.Add.Add
18 92
example.com/pgo/devirtualize.ExerciseFuncConcrete
example.com/pgo/devirtualize/mult%2epkg.MultFn
48 91

        given:
        sourceFile << """
            #define FUNC1(X) X
            #define FUNC2(X) (X)
            #define ARGS ("hello.h")

            #define HEADER_(X) X
            #define HEADER(X) HEADER_(FUNC1 FUNC2 X)

            #include HEADER(ARGS) // replaced by FUNC1 FUNC2 ("hello.h") then FUNC1 ("hello.h")
        """

        expect:
        resolve() == [header]
    }