CALL ·chainEnd(SB)
	RET
TEXT ·chainEnd(SB),NOSPLIT,$1000-0 // Should be reported twice
	RET

// Test reporting of rootless recursion
TEXT ·startRec(SB),NOSPLIT|NOFRAME,$0-0
	CALL ·startRec0(SB)
	RET
TEXT ·startRec0(SB),NOSPLIT|NOFRAME,$0-0
	CALL ·startRec(SB)

// instructions, use:
//
//	TEXT ·publicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
//		B	runtime·armPublicationBarrier(SB)
//
TEXT runtime·armPublicationBarrier(SB),NOSPLIT|NOFRAME,$0-0
	MOVB	runtime·goarm(SB), R11
	CMP	$7, R11
	BLT	2(PC)
	DMB	MB_ST
	RET

// AES hashing not implemented for ARM
TEXT runtime·memhash(SB),NOSPLIT|NOFRAME,$0-16
	JMP	runtime·memhashFallback(SB)

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

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

TEXT _rt0_amd64_windows(SB),NOSPLIT|NOFRAME,$-8
	JMP	_rt0_amd64(SB)

// When building with -buildmode=(c-shared or c-archive), this
// symbol is called. For dynamic libraries it is called when the
// library is loaded. For static libraries it is called when the

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

#include "go_asm.h"
#include "textflag.h"

TEXT ·Compare(SB),NOSPLIT|NOFRAME,$0-28
	MOVW	a_base+0(FP), R2
	MOVW	a_len+4(FP), R0
	MOVW	b_base+12(FP), R3
	MOVW	b_len+16(FP), R1
	ADD	$28, R13, R7
	B	cmpbody<>(SB)

TEXT runtime·cmpstring(SB),NOSPLIT|NOFRAME,$0-20
	MOVW	a_base+0(FP), R2
	MOVW	a_len+4(FP), R0
	MOVW	b_base+8(FP), R3
	MOVW	b_len+12(FP), R1
	ADD	$20, R13, R7

TEXT ·LoadAcq(SB),NOSPLIT|NOFRAME,$0-12
	JMP	·Load(SB)

// uint64 ·LoadAcq64(uint64 volatile* ptr)
TEXT ·LoadAcq64(SB),NOSPLIT|NOFRAME,$0-16
	JMP	·Load64(SB)

// uintptr ·LoadAcquintptr(uintptr volatile* ptr)
TEXT ·LoadAcquintptr(SB),NOSPLIT|NOFRAME,$0-16

TEXT runtime·retpolineR8(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(8)
TEXT runtime·retpolineR9(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(9)
TEXT runtime·retpolineR10(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(10)
TEXT runtime·retpolineR11(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(11)
TEXT runtime·retpolineR12(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(12)
TEXT runtime·retpolineR13(SB),NOSPLIT|NOFRAME,$0; RETPOLINE(13)

	return AnyValue(err)
}

func stack(skip, nFrames int) string {
	pcs := make([]uintptr, nFrames+1)
	n := runtime.Callers(skip+1, pcs)
	if n == 0 {
		return "(no stack)"
	}
	frames := runtime.CallersFrames(pcs[:n])
	var b strings.Builder
	i := 0
	for {
		frame, more := frames.Next()
		fmt.Fprintf(&b, "called from %s (%s:%d)\n", frame.Function, frame.File, frame.Line)

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

#include "go_asm.h"
#include "textflag.h"

TEXT ·Compare(SB),NOSPLIT|NOFRAME,$0-56
	MOVD	a_base+0(FP), R3
	MOVD	a_len+8(FP), R4
	MOVD	b_base+24(FP), R5
	MOVD	b_len+32(FP), R6
	LA	ret+48(FP), R7
	BR	cmpbody<>(SB)

TEXT runtime·cmpstring(SB),NOSPLIT|NOFRAME,$0-40
	MOVD	a_base+0(FP), R3
	MOVD	a_len+8(FP), R4
	MOVD	b_base+16(FP), R5
	MOVD	b_len+24(FP), R6
	LA	ret+32(FP), R7

TEXT runtime·sigresume(SB),NOSPLIT|NOFRAME,$0
	// Important: do not smash LR,
	// which is set to a live value when handling
	// a signal by pushing a call to sigpanic onto the stack.
	MOVW	R0, R13
	B	(R1)

TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0
	MOVW	$const_callbackVEH, R1
	B	sigtramp<>(SB)

TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0
	MOVW	$const_callbackFirstVCH, R1

#include "textflag.h"

// internal linking executable entry point.
// ios/amd64 only supports external linking.
TEXT _rt0_amd64_ios(SB),NOSPLIT|NOFRAME,$0
	UNDEF

// library entry point.
TEXT _rt0_amd64_ios_lib(SB),NOSPLIT|NOFRAME,$0