}

	case embedFiles:
		slicedata := v.Sym().Pkg.Lookup(v.Sym().Name + `.files`).Linksym()
		off := 0
		// []files pointed at by Files
		off = objw.SymPtr(slicedata, off, slicedata, 3*types.PtrSize) // []file, pointing just past slice
		off = objw.Uintptr(slicedata, off, uint64(len(files)))
		off = objw.Uintptr(slicedata, off, uint64(len(files)))

		// embed/embed.go type file is:

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	var s = []byte("abc")
	sh1 := *(*reflect.SliceHeader)(unsafe.Pointer(&s))
	ptr2 := unsafe.Pointer(unsafe.SliceData(s))
	if ptr2 != unsafe.Pointer(sh1.Data) {
		panic(fmt.Errorf("unsafe.SliceData %p != %p", ptr2, unsafe.Pointer(sh1.Data)))
	}

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

package issue64406

import (
	"unsafe"
)

func sliceData[E any, S ~[]E](s S) *E {
	return unsafe.SliceData(s)
}

func slice[E any, S ~*E](s S) []E {
	return unsafe.Slice(s, 0)
}

func f() {
	s := []uint32{0}
	_ = sliceData(s)
	_ = slice(&s)

		}

		change := &endpointsChange{}

		change.previous = cache.getEndpointsMap(serviceNN, esTracker.applied)

		for name, sliceData := range esTracker.pending {
			if sliceData.remove {
				delete(esTracker.applied, name)
			} else {
				esTracker.applied[name] = sliceData
			}

			delete(esTracker.pending, name)
		}

		change.current = cache.getEndpointsMap(serviceNN, esTracker.applied)

	}

	// unsafe.StringData
	{
		var s = "string"
		assert(string(unsafe.Slice(unsafe.StringData(s), len(s))) == s)
	}

	//unsafe.SliceData
	{
		var s = []byte("slice")
		assert(unsafe.String(unsafe.SliceData(s), len(s)) == string(s))
	}
}

func assert(ok bool) {
	if !ok {
		panic("FAIL")
	}
}

func mustPanic(f func()) {
	defer func() {

func ARC4Random(p []byte) {
	// macOS 11 and 12 abort if length is 0.
	if len(p) == 0 {
		return
	}
	syscall_syscall(abi.FuncPCABI0(libc_arc4random_buf_trampoline),
		uintptr(unsafe.Pointer(unsafe.SliceData(p))), uintptr(len(p)), 0)

func toString(b []byte) string {
	// unsafe.SliceData relies on cap whereas we want to rely on len
	if len(b) == 0 {
		return ""
	}
	// Copied from go 1.20.1 strings.Builder.String
	// https://github.com/golang/go/blob/202a1a57064127c3f19d96df57b9f9586145e21c/src/strings/builder.go#L48
	return unsafe.String(unsafe.SliceData(b), len(b))

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

package main

import "unsafe"

//go:noinline
func f(x []byte) bool {
	return unsafe.SliceData(x) != nil
}

//go:noinline
func g(x string) bool {
	return unsafe.StringData(x) != nil
}

func main() {
	if f(nil) {
		panic("bad f")
	}
	if g("") {
		panic("bad g")
	}

func toString(b []byte) string {
	// unsafe.SliceData relies on cap whereas we want to rely on len
	if len(b) == 0 {
		return ""
	}
	// Copied from go 1.20.1 strings.Builder.String
	// https://github.com/golang/go/blob/202a1a57064127c3f19d96df57b9f9586145e21c/src/strings/builder.go#L48
	return unsafe.String(unsafe.SliceData(b), len(b))

	{"Slice", `type B *byte; var b B; _ = unsafe.Slice(b, 0)`, `func(*byte, int) []byte`},

	{"SliceData", "var s []int; _ = unsafe.SliceData(s)", `func([]int) *int`},
	{"SliceData", "type S []int; var s S; _ = unsafe.SliceData(s)", `func([]int) *int`},

	{"String", `var p *byte; _ = unsafe.String(p, 1)`, `func(*byte, int) string`},