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

package main

import "math"

func checkClearSlice() {
	s := []int{1, 2, 3}
	clear(s)
	for i := range s {
		if s[i] != 0 {
			panic("clear not zeroing slice elem")
		}
	}

	clear([]int{})
}

func checkClearMap() {
	m1 := make(map[int]int)
	m1[0] = 0
	m1[1] = 1
	clear(m1)
	if len(m1) != 0 {
		panic("m1 is not cleared")
	}

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

package codegen

// This file contains code generation tests related to the handling of
// struct types.

// ------------- //
//    Zeroing    //
// ------------- //

type Z1 struct {
	a, b, c int
}

func Zero1(t *Z1) { // Issue #18370
	// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
	*t = Z1{}
}

type Z2 struct {

	VMAXPD.SAE (AX), Z2, K1, Z1      // ERROR "illegal SAE with memory argument"
	VADDPD.SAE X3, X2, K1, X1        // ERROR "unsupported SAE"
	// Unsupported zeroing.
	VFPCLASSPDX.Z $0, (AX), K2, K1   // ERROR "unsupported zeroing"
	VFPCLASSPDY.Z $0, (AX), K2, K1   // ERROR "unsupported zeroing"
	// Unsupported broadcast.
	VFPCLASSSD.BCST $0, (AX), K2, K1 // ERROR "unsupported broadcast"

// void runtime·memclrNoHeapPointers(void*, uintptr)
TEXT runtime·memclrNoHeapPointers<ABIInternal>(SB),NOSPLIT,$0-16
	// X10 = ptr
	// X11 = n

	// If less than 8 bytes, do single byte zeroing.
	MOV	$8, X9
	BLT	X11, X9, check4

	// Check alignment
	AND	$7, X10, X5
	BEQZ	X5, aligned

	// Zero one byte at a time until we reach 8 byte alignment.
	SUB	X5, X9, X5
	SUB	X5, X11, X11
align:

		h -= pow * uint32(s[i+n])
		if h == hashss && string(s[i:i+n]) == string(sep) {
			return i
		}
	}
	return -1
}

// MakeNoZero makes a slice of length n and capacity of at least n Bytes
// without zeroing the bytes (including the bytes between len and cap).
// It is the caller's responsibility to ensure uninitialized bytes
// do not leak to the end user.

// Malloc uses a FixAlloc wrapped around sysAlloc to manage its
// mcache and mspan objects.
//
// Memory returned by fixalloc.alloc is zeroed by default, but the
// caller may take responsibility for zeroing allocations by setting
// the zero flag to false. This is only safe if the memory never
// contains heap pointers.
//
// The caller is responsible for locking around FixAlloc calls.

   before they become visible as GC roots. Otherwise, the GC may
   observe stale heap pointers. See "Zero-initialization versus
   zeroing".

Zero-initialization versus zeroing
==================================

There are two types of zeroing in the runtime, depending on whether
the memory is already initialized to a type-safe state.

If memory is not in a type-safe state, meaning it potentially contains

func FilterInPlace[E any](s []E, f func(E) bool) []E {
	n := 0
	for _, val := range s {
		if f(val) {
			s[n] = val
			n++
		}
	}

	// If those elements contain pointers you might consider zeroing those elements
	// so that objects they reference can be garbage collected."
	var empty E
	for i := n; i < len(s); i++ {
		s[i] = empty
	}

	s = s[:n]
	return s
}

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

package main

import (
	"bytes"
	"fmt"
	"go/format"
	"log"
	"os"
)

// This program generates tests to verify that zeroing operations
// zero the data they are supposed to and clobber no adjacent values.

// run as `go run zeroGen.go`.  A file called zero.go
// will be written into the parent directory containing the tests.

	REG_AR14
	REG_AR15

	REG_RESERVED // end of allocated registers

	REGARG  = -1      // -1 disables passing the first argument in register
	REGRT1  = REG_R3  // used during zeroing of the stack - not reserved
	REGRT2  = REG_R4  // used during zeroing of the stack - not reserved
	REGTMP  = REG_R10 // scratch register used in the assembler and linker
	REGTMP2 = REG_R11 // scratch register used in the assembler and linker