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

//go:build gc

#include "textflag.h"

TEXT ·RewindAndSetgid(SB),NOSPLIT,$0-0
	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), R15

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R5
	MOVW	$1, 0(R5)

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R3

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

#include "textflag.h"

TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R3

	// Ask signaller to setgid
	MOVW	$1, R12
	DBAR
	MOVW	R12, ·Baton(SB)
	DBAR

	// Wait for setgid completion
loop:
	DBAR

//go:build gc

#include "textflag.h"

TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
	// Save link register
	MOVD	R30, R9

	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADD	$(1024 * 8), RSP

	// Ask signaller to setgid
	MOVD	$·Baton(SB), R0
	MOVD	$1, R1
storeloop:
	LDAXRW	(R0), R2
	STLXRW	R1, (R0), R3
	CBNZ	R3, storeloop

// variables with types defined in a shared library.
// See issue 39927.

// This test run under GODEBUG=clobberfree=1. The check
// *x[i] == 12345 depends on this debug mode to clobber
// the value if the object is freed prematurely.

package main

import (
	"fmt"
	"runtime"
	"testshared/gcdata/p"
)

var x p.T

func main() {
	for i := range x {
		x[i] = new(int)

// Package framepointer defines an Analyzer that reports assembly code
// that clobbers the frame pointer before saving it.
package framepointer

import (
	"go/build"
	"regexp"
	"strings"

	"golang.org/x/tools/go/analysis"
	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
)

const Doc = "report assembly that clobbers the frame pointer before saving it"

var Analyzer = &analysis.Analyzer{

	REGSP     int
	MAXWIDTH  int64
	SoftFloat bool

	PadFrame func(int64) int64

	// ZeroRange zeroes a range of memory on stack. It is only inserted
	// at function entry, and it is ok to clobber registers.
	ZeroRange func(*objw.Progs, *obj.Prog, int64, int64, *uint32) *obj.Prog

	Ginsnop func(*objw.Progs) *obj.Prog

	// SSAMarkMoves marks any MOVXconst ops that need to avoid clobbering flags.

				if elf.ProgType(phdr.Type) == elf.PT_NOTE {
					// Increase the size so we keep
					// reading notes.
					order.PutUint64(data[phoff+4*8:], phdr.Filesz+1)

					// Clobber the Align field to zero.
					order.PutUint64(data[phoff+6*8:], 0)

					// Clobber the note type so we
					// keep reading notes.
					order.PutUint32(data[phdr.Off+12:], 0)
				}

				phoff += phsize
			}

	// Push the LR to stack, as we'll clobber it in order to
	// push the call. The function being pushed is responsible
	// for restoring the LR and setting the SP back.
	// This extra space is known to gentraceback.
	sp := c.sp() - sys.MinFrameSize
	c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()
	// In PIC mode, we'll set up (i.e. clobber) R2 on function
	// entry. Save it ahead of time.

	// we can leave in the flags register at the end of the block. (There
	// is no place to put a flag regeneration instruction.)
	for _, b := range f.Blocks {
		if b.Kind == BlockDefer {
			// Defer blocks internally use/clobber the flags value.
			end[b.ID] = nil
			continue
		}
		for _, v := range b.ControlValues() {
			if v.Type.IsFlags() && end[b.ID] != v {
				end[b.ID] = nil
			}
		}
	}

	pc := uintptr(c.eip())
	sp := uintptr(c.esp())

	if shouldPushSigpanic(gp, pc, *(*uintptr)(unsafe.Pointer(sp))) {
		c.pushCall(abi.FuncPCABIInternal(sigpanic), pc)
	} else {
		// Not safe to push the call. Just clobber the frame.
		c.set_eip(uint32(abi.FuncPCABIInternal(sigpanic)))
	}
}

func (c *sigctxt) pushCall(targetPC, resumePC uintptr) {
	// Make it look like we called target at resumePC.
	sp := uintptr(c.esp())