package ssa

// loopRotate converts loops with a check-loop-condition-at-beginning
// to loops with a check-loop-condition-at-end.
// This helps loops avoid extra unnecessary jumps.
//
//	 loop:
//	   CMPQ ...
//	   JGE exit
//	   ...
//	   JMP loop
//	 exit:
//
//	  JMP entry
//	loop:
//	  ...
//	entry:
//	  CMPQ ...
//	  JLT loop
func loopRotate(f *Func) {
	loopnest := f.loopnest()

  for (int i = 0; i < n; ++i) result.push_back(ToOutput(output_tensors[i]));
  return result;
}

// The backprop loop counter and main backprop loop run in their own execution
// frame (conceptually, the main forward loop and forward loop counter run
// together in a frame, then the backprop loop counter and backprop loop run
// together in a different frame). This returns the frame name to use for the
// backprop while loops.

// Package loopclosure defines an Analyzer that checks for references to
// enclosing loop variables from within nested functions.
//
// # Analyzer loopclosure
//
// loopclosure: check references to loop variables from within nested functions
//
// This analyzer reports places where a function literal references the
// iteration variable of an enclosing loop, and the loop calls the function
// in such a way (e.g. with go or defer) that it may outlive the loop

package escape

var x bool

func f1() {
	var p *int
loop:
	if x {
		goto loop
	}
	// BAD: We should be able to recognize that there
	// aren't any more "goto loop" after here.
	p = new(int) // ERROR "escapes to heap"
	_ = p
}

func f2() {
	var p *int
	if x {
	loop:
		goto loop
	} else {
		p = new(int) // ERROR "does not escape"
	}
	_ = p
}

func f3() {

it does not call the loop body again after it has returned false or
after the entire loop has exited (it might retain a copy of the body
function, or pass it to another goroutine) -- each generated loop has
its own #stateK variable that is used to check for permitted call
patterns to the yield function for a loop body.

The state values are:

abi.RF_DONE = 0      // body of loop has exited in a non-panic way

		for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop"
			if x == 4 { // ERROR "Branch prediction rule stay in loop"
				return a
			}
			for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop"
				for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop"
					a -= j * i
				}
				a += j
			}
		}
	}
	return a
}

//go:build unix && !dragonfly && !freebsd && !netbsd

package unix

import "syscall"

// POSIX.1-2008 says it's ELOOP. Most platforms follow:
//
//   - aix: O_NOFOLLOW not documented (https://www.ibm.com/docs/ssw_aix_73/o_bostechref/open.html), assuming ELOOP
//   - android: see linux
//   - darwin: https://github.com/apple/darwin-xnu/blob/main/bsd/man/man2/open.2

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

package main

func f(j int) {
loop:
	for i := 0; i < 4; i++ {
		if i == 1 {
			continue loop
		}
		println(j, i)
	}
}

func main() {
loop:
	for j := 0; j < 5; j++ {
		f(j)
		if j == 3 {
			break loop
		}
	}

	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10
	BNE	X12, X15, loop
	ADD	$1, X14
	JMP	loop

done:
	MOV	X14, X10
	RET

TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = s_base
	// X11 = s_len
	// X12 = byte to count
	AND	$0xff, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15

				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},
		{"int8", ValueOf(int8(4)), func(t *testing.T, s iter.Seq[Value]) {
			i := int8(0)
			for v := range s {
				if v.Interface().(int8) != i {
					t.Fatalf("got %d, want %d", v.Int(), i)
				}
				i++
			}
			if i != 4 {
				t.Fatalf("should loop four times")
			}
		}},