someglobal1++
		someglobal1++
	}
}

func standinacorner2(i int) {
	// contains an irreducible loop containing changes to memory
	if i != 0 {
		goto midloop
	}

loop:
	if someglobal2&1 != 0 {
		goto done
	}
	someglobal2++
midloop:
	someglobal2++
	goto loop

done:
	return
}

func standinacorner3() {
	for someglobal3&1 == 0 {
		if someglobal3&2 != 0 {

    %island2 = tf_executor.island(%island1) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    // expected-warning@+1 {{unexpected control dependency path: path 0, node 2 (intermediate)}}
    %island3 = tf_executor.island(%island2) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }

	MOVD	$1, R1
storeloop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, storeloop

	// Wait for setgid completion
	MOVW	$0, R1
	MOVW	$0, R2
loop:
	LDAXRW	(R0), R3
	CMPW	R1, R3
	BNE	loop
	STLXRW	R2, (R0), R3
	CBNZ	R3, loop

	// Restore stack
	SUB	$(1024 * 8), RSP

	MOVD	R9, R30

package org.gradle.kotlin.dsl.concurrent

import java.util.concurrent.ArrayBlockingQueue
import java.util.concurrent.TimeUnit


internal
class EventLoop<T>(
    name: String = "Gradle Kotlin DSL Event Loop",
    val loop: (() -> T?) -> Unit
) {

    fun accept(event: T): Boolean {
        if (q.offer(event, offerTimeoutMillis, TimeUnit.MILLISECONDS)) {
            consumer.poke()
            return true
        }

	Call memeqbody<>(SB)
	I64Store8 ret+16(FP)
	RET

// params: a, b, len
// ret: 0/1
TEXT memeqbody<>(SB), NOSPLIT, $0-0
	Get R0
	Get R1
	I64Eq
	If
		I64Const $1
		Return
	End

loop:
	Loop
		Get R2
		I64Eqz
		If
			I64Const $1
			Return
		End

		Get R0
		I32WrapI64
		I64Load8U $0
		Get R1
		I32WrapI64
		I64Load8U $0
		I64Ne
		If
			I64Const $0
			Return

	// a Phi op takes the store in the same block as argument.
	// See issue #19067.
	c := testConfig(t)
	ptrType := c.config.Types.BytePtr
	fun := c.Fun("entry",
		Bloc("entry",
			Valu("start", OpInitMem, types.TypeMem, 0, nil),
			Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
			Valu("sp", OpSP, c.config.Types.Uintptr, 0, nil),
			Goto("loop")),
		Bloc("loop",

	SGTU	R1, R2, R7
	MOVW	R1, R8
	CMOVN	R7, R2, R8	// R8 is min(R1, R2)

	ADDU	R3, R8	// R3 is current byte in a, R8 is last byte in a to compare
loop:
	BEQ	R3, R8, samebytes

	MOVBU	(R3), R6
	ADDU	$1, R3
	MOVBU	(R4), R7
	ADDU	$1, R4
	BEQ	R6, R7 , loop

	SGTU	R6, R7, R8
	MOVW	$-1, R6
	CMOVZ	R8, R6, R8
	JMP	cmp_ret
samebytes:
	SGTU	R1, R2, R6
	SGTU	R2, R1, R7
	SUBU	R7, R6, R8
cmp_ret:

// Copyright 2021 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.

package a

func F[T any](T) {
Loop:
	for {
		break Loop
	}

			fmt.Fprintln(os.Stderr, "no panic from segv")
			os.Exit(1)
		}
	}()
	*P = 0
	fmt.Fprintln(os.Stderr, "continued after segv")
	os.Exit(1)
}

// Noop ensures that the Go runtime is initialized.
//
//export Noop
func Noop() {
}

// Raise SIGPIPE.
//
//export GoRaiseSIGPIPE
func GoRaiseSIGPIPE() {
	C.CRaiseSIGPIPE()
}

func main() {

// since 4 values are processed for each
// loop iteration, and is guaranteed to be > 0.
// If other callers are added this function might
// need to change.
TEXT addMulVVWx<>(SB), NOSPLIT, $0
	MOVD	z+0(FP), R3
	MOVD	x+8(FP), R4
	MOVD	y+16(FP), R5

	MOVD	$0, R9		// R9 = c = 0
	MOVD	R6, CTR		// Initialize loop counter
	PCALIGN	$16

loop:
	MOVD	0(R4), R14	// x[i]
	MOVD	8(R4), R16	// x[i+1]