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

// This test makes sure we don't use 4-byte unaligned writes
// to zero memory on architectures that don't support them.

package main

type T struct {
	a byte
	b [10]byte
}

//go:noinline
func f(t *T) {
	// t will be aligned, so &t.b won't be.
	t.b = [10]byte{}
}

var t T

func main() {
	f(&t)

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

//go:build ignore

package main

// This file tests that we don't generate an incorrect field location
// for a bitfield that appears aligned.

/*
struct bitfields {
    unsigned int B1     :  5;
    unsigned int B2     :  1;
    unsigned int B3     :  1;
    unsigned int B4     :  1;
    unsigned int Short1 : 16; // misaligned on 8 bit boundary

// returns memory unconditionally. It is used if an out-of-memory error has been
// detected midway through an allocation or to carve out an aligned section of
// the address space. It is okay if sysFree is a no-op only if sysReserve always
// returns a memory region aligned to the heap allocator's alignment
// restrictions.
//
// sysStat must be non-nil.
//

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

// Issue 4396. Arrays of bytes are not required to be
// word aligned. 5g should use MOVB to load the address
// of s.g[0] for its nil check.
//
// This test _may_ fail on arm, but requires the host to 
// trap unaligned loads. This is generally done with
//
// echo "4" > /proc/cpu/alignment

package main

var s = struct {
	// based on lzw.decoder

//
//	R14-R31
//	CR2-4
//	VR20-31
//	F14-F31
//
// xcoff(aix) and ELFv1 are similar, but may only require a
// subset of these.
//
// These macros assume a 16 byte aligned stack pointer. This
// is required by ELFv1, ELFv2, and AIX PPC64.

#define SAVE_GPR_SIZE (18*8)
#define SAVE_GPR(offset)               \
	MOVD	R14, (offset+8*0)(R1)  \
	MOVD	R15, (offset+8*1)(R1)  \

		stream.XORKeyStream(buf, buf)
	}
}

// If we test exactly 1K blocks, we would generate exact multiples of
// the cipher's block size, and the cipher stream fragments would
// always be wordsize aligned, whereas non-aligned is a more typical
// use-case.
const almost1K = 1024 - 5
const almost8K = 8*1024 - 5

func BenchmarkAESCFBEncrypt1K(b *testing.B) {
	benchmarkAESStream(b, cipher.NewCFBEncrypter, make([]byte, almost1K))
}

		salign = 1
	case "darwin", "ios", "illumos", "solaris":
		// NOTE: It seems like 64-bit Darwin, Illumos and Solaris
		// kernels still require 32-bit aligned access to network
		// subsystem.
		if sizeofPtr == 8 {
			salign = 4
		}
	case "netbsd", "openbsd":
		// NetBSD and OpenBSD armv7 require 64-bit alignment.
		if runtime.GOARCH == "arm" {
			salign = 8
		}
		// NetBSD aarch64 requires 128-bit alignment.

TEXT runtime·memclrNoHeapPointers<ABIInternal>(SB),NOSPLIT,$0-16
	ADDV	R4, R5, R6

	// if less than 8 bytes, do one byte at a time
	SGTU	$8, R5, R8
	BNE	R8, out

	// do one byte at a time until 8-aligned
	AND	$7, R4, R8
	BEQ	R8, words
	MOVB	R0, (R4)
	ADDV	$1, R4
	JMP	-4(PC)

words:
	// do 8 bytes at a time if there is room
	ADDV	$-7, R6, R5

	PCALIGN	$16
	SGTU	R5, R4, R8
	BEQ	R8, out

		// addr be page-aligned, and allows length to be zero.
		throw("unaligned sysNoHugePageOS")
	}
	madvise(v, n, _MADV_NOHUGEPAGE)
}

func sysHugePageCollapseOS(v unsafe.Pointer, n uintptr) {
	if uintptr(v)&(physPageSize-1) != 0 {
		// The Linux implementation requires that the address
		// addr be page-aligned, and allows length to be zero.
		throw("unaligned sysHugePageCollapseOS")
	}

	// nil pointer is always suitably aligned (#47430).
	if p == nil {
		return
	}

	// Check that (*[n]elem)(p) is appropriately aligned.
	// Note that we allow unaligned pointers if the types they point to contain
	// no pointers themselves. See issue 37298.
	// TODO(mdempsky): What about fieldAlign?
	if elem.Pointers() && uintptr(p)&(uintptr(elem.Align_)-1) != 0 {
		throw("checkptr: misaligned pointer conversion")