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

// Stress test setgid and thread creation. A thread
// can get a SIGSETXID signal early on at thread
// initialization, causing crash. See issue 53374.

package cgotest

/*
#include <sys/types.h>
#include <unistd.h>
*/
import "C"

import (
	"runtime"
	"testing"
)

	runtime.SetFinalizer(&s, func(p *string) { close(done) })
	return unsafe.Pointer(&s)
}

//go:noinline
//go:uintptrescapes
func before(p uintptr) int {
	runtime.GC()
	select {
	case <-done:
		panic("GC early")
	default:
	}
	return 0
}

func after() int {
	runtime.GC()
	runtime.GC()
	<-done
	return 0
}

func main() {
	_ = before(uintptr(setup())) + after()

		return;
	registerAbortHandler();
}
*/
import "C"
import "os"

func init() {
	register("CgoCatchPanic", CgoCatchPanic)
}

// Test that the SIGABRT raised by panic can be caught by an early signal handler.
func CgoCatchPanic() {
	if _, ok := os.LookupEnv("CGOCATCHPANIC_EARLY_HANDLER"); !ok {
		C.registerAbortHandler()
	}
	panic("catch me")

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

// Only works on systems with syscall.Close.
// We need a fast system call to provoke the race,
// and Close(-1) is nearly universally fast.

//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || plan9

package runtime_test

import (
	"runtime"
	"sync"
	"sync/atomic"
	"syscall"
	"testing"
)

}

func setup() {
	var Ts []interface{}
	buf := make([]byte, 128)
	
	for i := 0; i < 10000; i++ {
		s := string(buf)
		t := &T{ptr: new(*int)}
		runtime.SetFinalizer(t.ptr, func(**int) { panic("*int freed too early") })
		Ts = append(Ts, t)
		things = append(things, s[len(s):])
	}
	
	things = append(things, Ts...)

		tags[tag] = true
	}
	return tags
}

var (
	anyTags     map[string]bool
	anyTagsOnce sync.Once
)

// AnyTags returns a special set of build tags that satisfy nearly all
// build tag expressions. Only "ignore" and malformed build tag requirements
// are considered false.
func AnyTags() map[string]bool {
	anyTagsOnce.Do(func() {
		anyTags = map[string]bool{"*": true}
	})

	t.next = u
	for _, p := range t.stuff {
		if isFoo(t, p) {
			return
		}
	}
}

//go:noinline
func isFoo(t *thing, b big) bool {
	return true
}

func main() {
	growstack() // Use stack early to prevent growth during test, which confuses gdb
	t := &thing{name: "t", self: nil, next: nil, stuff: make([]big, 1)}
	u := thing{name: "u", self: t, next: t, stuff: make([]big, 1)}
	test(t, &u)
}

var snk string

 * limitations under the License.
 */

package org.gradle.model.internal.core;

import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

/**
 * An action that should execute early in the lifecycle of a model element, to define rules for the element.
 */
public interface DeferredModelAction {
    ModelRuleDescriptor getDescriptor();

    void execute(MutableModelNode node, ModelActionRole role);

// errorcheck -0 -m

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 23521: improve early DCE for if without explicit else.

package p

//go:noinline
func nonleaf() {}

const truth = true

func f() int { // ERROR "can inline f"
	if truth {
		return 0
	}
	// If everything below is removed, as it should,

	u2 := &U{&s3, &ps4}  // ERROR "&U{...} does not escape$"
	u3 := &U{&s5, &ps6}  // ERROR "&U{...} escapes to heap$"
	v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$"
	Ssink = v.UPiSPa()   // Ssink = &s3 (only &s3 really escapes)
}

// BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3
func tUPiSPb() {
	s1 := "ant"
	s2 := "bat" // ERROR "moved to heap: s2$"