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

//go:build asan

#include "go_asm.h"
#include "go_tls.h"
#include "funcdata.h"
#include "textflag.h"

// This is like race_amd64.s, but for the asan calls.
// See race_amd64.s for detailed comments.

#ifdef GOOS_windows
#define RARG0 CX
#define RARG1 DX
#define RARG2 R8
#define RARG3 R9

import (
	"fmt"
	"unsafe"
)

func main() {
	a := 1
	b := 2
	c := add(a, b)
	d := a + b
	fmt.Println(c, d)
}

//go:noinline
func add(a1, b1 int) (ret int) {
	// The return value
	// When -asan is enabled, the unsafe.Pointer(&ret) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&ret), 1*unsafe.Sizeof(int(1))))
	*p = 123 // BOOM
	ret = a1 + b1
	return

class FunctionalTestProject(
    val model: CIBuildModel,
    functionalTestBucketProvider: FunctionalTestBucketProvider,
    val testCoverage: TestCoverage,
    val stage: Stage
) : Project({
    this.id(testCoverage.asId(model))
    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {

		// compute argument signatures: instantiate if needed
		j := n
		for _, i := range genericArgs {
			arg := args[i]
			asig := arg.typ.(*Signature)
			k := j + asig.TypeParams().Len()
			// targs[j:k] are the inferred type arguments for asig
			arg.typ = check.instantiateSignature(call.Pos(), arg.expr, asig, targs[j:k], nil) // TODO(gri) provide xlist if possible (partial instantiations)

package main

/*
#include <stdlib.h>
#include <stdio.h>

void test(int* a) {
	// Access Go pointer out of bounds.
	a[3] = 300;          // BOOM
	// We shouldn't get here; asan should stop us first.
	printf("a[3]=%d\n", a[3]);
}*/
import "C"

func main() {
	var cIntArray [2]C.int
	C.test(&cIntArray[0]) // cIntArray is moved to heap.

//go:build goexperiment.arenas

package main

import "arena"

func main() {
	a := arena.NewArena()
	x := arena.New[[200]byte](a)
	x[0] = 9
	a.Free()
	// Use after free.
	//
	// ASAN should detect this deterministically as Free
	// should poison the arena memory.
	//
	// MSAN should detect that this access is to freed
	// memory. This may crash with an "accessed freed arena

import "C"
import (
	"fmt"
	"unsafe"
)

func main() {
	a := C.f()
	q5 := (*C.int)(unsafe.Add(unsafe.Pointer(a), 4*5))
	// Access to C pointer out of bounds.
	*q5 = 100 // BOOM
	// We shouldn't get here; asan should stop us first.
	fmt.Printf("q5: %d, %x\n", *q5, q5)

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

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	a := 1
	b := 2
	// The local variables.
	// When -asan is enabled, the unsafe.Pointer(&a) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&a), 1*unsafe.Sizeof(int(1))))
	*p = 20 // BOOM
	d := a + b
	fmt.Println(d)

 free(p);
 return p;
}
*/
import "C"
import "fmt"

func main() {
	// C passes Go an invalid pointer.
	a := C.test()
	// Use after free
	*a = 2 // BOOM
	// We shouldn't get here; asan should stop us first.
	fmt.Println(*a)

import (
	"fmt"
	"unsafe"
)

func main() {
	a := 1
	b := 2
	c := add(a, b)
	d := a + b
	fmt.Println(c, d)
}

//go:noinline
func add(a1, b1 int) int {
	// The arguments.
	// When -asan is enabled, unsafe.Pointer(&a1) conversion is escaping.
	var p *int = (*int)(unsafe.Add(unsafe.Pointer(&a1), 1*unsafe.Sizeof(int(1))))
	*p = 10 // BOOM
	return a1 + b1