github.com/MerlinKodo/gvisor@v0.0.0-20231110090155-957f62ecf90e/pkg/sentry/syscalls/linux/linux_abi_autogen_unsafe.go

// Automatically generated marshal implementation. See tools/go_marshal.

package linux

import (
	"io"
	"reflect"
	"runtime"
	"unsafe"

	"github.com/MerlinKodo/gvisor/pkg/gohacks"
	"github.com/MerlinKodo/gvisor/pkg/hostarch"
	"github.com/MerlinKodo/gvisor/pkg/marshal"
)

// Marshallable types used by this file.
var _ marshal.Marshallable = (*MessageHeader64)(nil)
var _ marshal.Marshallable = (*SchedParam)(nil)
var _ marshal.Marshallable = (*multipleMessageHeader64)(nil)
var _ marshal.Marshallable = (*rlimit64)(nil)
var _ marshal.Marshallable = (*sigSetWithSize)(nil)
var _ marshal.Marshallable = (*userSockFprog)(nil)

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (s *sigSetWithSize) SizeBytes() int {
	return 16
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (s *sigSetWithSize) MarshalBytes(dst []byte) []byte {
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(s.sigsetAddr))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(s.sizeofSigset))
	dst = dst[8:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (s *sigSetWithSize) UnmarshalBytes(src []byte) []byte {
	s.sigsetAddr = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	s.sizeofSigset = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (s *sigSetWithSize) Packed() bool {
	return true
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (s *sigSetWithSize) MarshalUnsafe(dst []byte) []byte {
	size := s.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(s), uintptr(size))
	return dst[size:]
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (s *sigSetWithSize) UnmarshalUnsafe(src []byte) []byte {
	size := s.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(s), unsafe.Pointer(&src[0]), uintptr(size))
	return src[size:]
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (s *sigSetWithSize) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (s *sigSetWithSize) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return s.CopyOutN(cc, addr, s.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (s *sigSetWithSize) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (s *sigSetWithSize) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return s.CopyInN(cc, addr, s.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (s *sigSetWithSize) WriteTo(writer io.Writer) (int64, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return int64(length), err
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (r *rlimit64) SizeBytes() int {
	return 16
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (r *rlimit64) MarshalBytes(dst []byte) []byte {
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(r.Cur))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(r.Max))
	dst = dst[8:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (r *rlimit64) UnmarshalBytes(src []byte) []byte {
	r.Cur = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	r.Max = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (r *rlimit64) Packed() bool {
	return true
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (r *rlimit64) MarshalUnsafe(dst []byte) []byte {
	size := r.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(r), uintptr(size))
	return dst[size:]
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (r *rlimit64) UnmarshalUnsafe(src []byte) []byte {
	size := r.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(r), unsafe.Pointer(&src[0]), uintptr(size))
	return src[size:]
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (r *rlimit64) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(r)))
	hdr.Len = r.SizeBytes()
	hdr.Cap = r.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that r
	// must live until the use above.
	runtime.KeepAlive(r) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (r *rlimit64) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return r.CopyOutN(cc, addr, r.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (r *rlimit64) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(r)))
	hdr.Len = r.SizeBytes()
	hdr.Cap = r.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that r
	// must live until the use above.
	runtime.KeepAlive(r) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (r *rlimit64) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return r.CopyInN(cc, addr, r.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (r *rlimit64) WriteTo(writer io.Writer) (int64, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(r)))
	hdr.Len = r.SizeBytes()
	hdr.Cap = r.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that r
	// must live until the use above.
	runtime.KeepAlive(r) // escapes: replaced by intrinsic.
	return int64(length), err
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (s *SchedParam) SizeBytes() int {
	return 4
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (s *SchedParam) MarshalBytes(dst []byte) []byte {
	hostarch.ByteOrder.PutUint32(dst[:4], uint32(s.schedPriority))
	dst = dst[4:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (s *SchedParam) UnmarshalBytes(src []byte) []byte {
	s.schedPriority = int32(hostarch.ByteOrder.Uint32(src[:4]))
	src = src[4:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (s *SchedParam) Packed() bool {
	return true
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (s *SchedParam) MarshalUnsafe(dst []byte) []byte {
	size := s.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(s), uintptr(size))
	return dst[size:]
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (s *SchedParam) UnmarshalUnsafe(src []byte) []byte {
	size := s.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(s), unsafe.Pointer(&src[0]), uintptr(size))
	return src[size:]
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (s *SchedParam) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (s *SchedParam) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return s.CopyOutN(cc, addr, s.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (s *SchedParam) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (s *SchedParam) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return s.CopyInN(cc, addr, s.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (s *SchedParam) WriteTo(writer io.Writer) (int64, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(s)))
	hdr.Len = s.SizeBytes()
	hdr.Cap = s.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that s
	// must live until the use above.
	runtime.KeepAlive(s) // escapes: replaced by intrinsic.
	return int64(length), err
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (u *userSockFprog) SizeBytes() int {
	return 10 +
		1*6
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (u *userSockFprog) MarshalBytes(dst []byte) []byte {
	hostarch.ByteOrder.PutUint16(dst[:2], uint16(u.Len))
	dst = dst[2:]
	// Padding: dst[:sizeof(byte)*6] ~= [6]byte{0}
	dst = dst[1*(6):]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(u.Filter))
	dst = dst[8:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (u *userSockFprog) UnmarshalBytes(src []byte) []byte {
	u.Len = uint16(hostarch.ByteOrder.Uint16(src[:2]))
	src = src[2:]
	// Padding: ~ copy([6]byte(u._), src[:sizeof(byte)*6])
	src = src[1*(6):]
	u.Filter = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (u *userSockFprog) Packed() bool {
	return true
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (u *userSockFprog) MarshalUnsafe(dst []byte) []byte {
	size := u.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(u), uintptr(size))
	return dst[size:]
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (u *userSockFprog) UnmarshalUnsafe(src []byte) []byte {
	size := u.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(u), unsafe.Pointer(&src[0]), uintptr(size))
	return src[size:]
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (u *userSockFprog) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(u)))
	hdr.Len = u.SizeBytes()
	hdr.Cap = u.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that u
	// must live until the use above.
	runtime.KeepAlive(u) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (u *userSockFprog) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return u.CopyOutN(cc, addr, u.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (u *userSockFprog) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(u)))
	hdr.Len = u.SizeBytes()
	hdr.Cap = u.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that u
	// must live until the use above.
	runtime.KeepAlive(u) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (u *userSockFprog) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return u.CopyInN(cc, addr, u.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (u *userSockFprog) WriteTo(writer io.Writer) (int64, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(u)))
	hdr.Len = u.SizeBytes()
	hdr.Cap = u.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that u
	// must live until the use above.
	runtime.KeepAlive(u) // escapes: replaced by intrinsic.
	return int64(length), err
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (m *MessageHeader64) SizeBytes() int {
	return 56
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (m *MessageHeader64) MarshalBytes(dst []byte) []byte {
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(m.Name))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint32(dst[:4], uint32(m.NameLen))
	dst = dst[4:]
	// Padding: dst[:sizeof(uint32)] ~= uint32(0)
	dst = dst[4:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(m.Iov))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(m.IovLen))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(m.Control))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint64(dst[:8], uint64(m.ControlLen))
	dst = dst[8:]
	hostarch.ByteOrder.PutUint32(dst[:4], uint32(m.Flags))
	dst = dst[4:]
	// Padding: dst[:sizeof(int32)] ~= int32(0)
	dst = dst[4:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (m *MessageHeader64) UnmarshalBytes(src []byte) []byte {
	m.Name = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	m.NameLen = uint32(hostarch.ByteOrder.Uint32(src[:4]))
	src = src[4:]
	// Padding: var _ uint32 ~= src[:sizeof(uint32)]
	src = src[4:]
	m.Iov = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	m.IovLen = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	m.Control = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	m.ControlLen = uint64(hostarch.ByteOrder.Uint64(src[:8]))
	src = src[8:]
	m.Flags = int32(hostarch.ByteOrder.Uint32(src[:4]))
	src = src[4:]
	// Padding: var _ int32 ~= src[:sizeof(int32)]
	src = src[4:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (m *MessageHeader64) Packed() bool {
	return true
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (m *MessageHeader64) MarshalUnsafe(dst []byte) []byte {
	size := m.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(m), uintptr(size))
	return dst[size:]
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (m *MessageHeader64) UnmarshalUnsafe(src []byte) []byte {
	size := m.SizeBytes()
	gohacks.Memmove(unsafe.Pointer(m), unsafe.Pointer(&src[0]), uintptr(size))
	return src[size:]
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (m *MessageHeader64) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (m *MessageHeader64) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return m.CopyOutN(cc, addr, m.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (m *MessageHeader64) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (m *MessageHeader64) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return m.CopyInN(cc, addr, m.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (m *MessageHeader64) WriteTo(writer io.Writer) (int64, error) {
	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return int64(length), err
}

// SizeBytes implements marshal.Marshallable.SizeBytes.
func (m *multipleMessageHeader64) SizeBytes() int {
	return 8 +
		(*MessageHeader64)(nil).SizeBytes()
}

// MarshalBytes implements marshal.Marshallable.MarshalBytes.
func (m *multipleMessageHeader64) MarshalBytes(dst []byte) []byte {
	dst = m.msgHdr.MarshalUnsafe(dst)
	hostarch.ByteOrder.PutUint32(dst[:4], uint32(m.msgLen))
	dst = dst[4:]
	// Padding: dst[:sizeof(int32)] ~= int32(0)
	dst = dst[4:]
	return dst
}

// UnmarshalBytes implements marshal.Marshallable.UnmarshalBytes.
func (m *multipleMessageHeader64) UnmarshalBytes(src []byte) []byte {
	src = m.msgHdr.UnmarshalUnsafe(src)
	m.msgLen = uint32(hostarch.ByteOrder.Uint32(src[:4]))
	src = src[4:]
	// Padding: var _ int32 ~= src[:sizeof(int32)]
	src = src[4:]
	return src
}

// Packed implements marshal.Marshallable.Packed.
//
//go:nosplit
func (m *multipleMessageHeader64) Packed() bool {
	return m.msgHdr.Packed()
}

// MarshalUnsafe implements marshal.Marshallable.MarshalUnsafe.
func (m *multipleMessageHeader64) MarshalUnsafe(dst []byte) []byte {
	if m.msgHdr.Packed() {
		size := m.SizeBytes()
		gohacks.Memmove(unsafe.Pointer(&dst[0]), unsafe.Pointer(m), uintptr(size))
		return dst[size:]
	}
	// Type multipleMessageHeader64 doesn't have a packed layout in memory, fallback to MarshalBytes.
	return m.MarshalBytes(dst)
}

// UnmarshalUnsafe implements marshal.Marshallable.UnmarshalUnsafe.
func (m *multipleMessageHeader64) UnmarshalUnsafe(src []byte) []byte {
	if m.msgHdr.Packed() {
		size := m.SizeBytes()
		gohacks.Memmove(unsafe.Pointer(m), unsafe.Pointer(&src[0]), uintptr(size))
		return src[size:]
	}
	// Type multipleMessageHeader64 doesn't have a packed layout in memory, fallback to UnmarshalBytes.
	return m.UnmarshalBytes(src)
}

// CopyOutN implements marshal.Marshallable.CopyOutN.
func (m *multipleMessageHeader64) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	if !m.msgHdr.Packed() {
		// Type multipleMessageHeader64 doesn't have a packed layout in memory, fall back to MarshalBytes.
		buf := cc.CopyScratchBuffer(m.SizeBytes()) // escapes: okay.
		m.MarshalBytes(buf)                        // escapes: fallback.
		return cc.CopyOutBytes(addr, buf[:limit])  // escapes: okay.
	}

	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := cc.CopyOutBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return length, err
}

// CopyOut implements marshal.Marshallable.CopyOut.
func (m *multipleMessageHeader64) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return m.CopyOutN(cc, addr, m.SizeBytes())
}

// CopyInN implements marshal.Marshallable.CopyInN.
func (m *multipleMessageHeader64) CopyInN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
	if !m.msgHdr.Packed() {
		// Type multipleMessageHeader64 doesn't have a packed layout in memory, fall back to UnmarshalBytes.
		buf := cc.CopyScratchBuffer(m.SizeBytes())       // escapes: okay.
		length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
		// Unmarshal unconditionally. If we had a short copy-in, this results in a
		// partially unmarshalled struct.
		m.UnmarshalBytes(buf) // escapes: fallback.
		return length, err
	}

	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := cc.CopyInBytes(addr, buf[:limit]) // escapes: okay.
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return length, err
}

// CopyIn implements marshal.Marshallable.CopyIn.
func (m *multipleMessageHeader64) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
	return m.CopyInN(cc, addr, m.SizeBytes())
}

// WriteTo implements io.WriterTo.WriteTo.
func (m *multipleMessageHeader64) WriteTo(writer io.Writer) (int64, error) {
	if !m.msgHdr.Packed() {
		// Type multipleMessageHeader64 doesn't have a packed layout in memory, fall back to MarshalBytes.
		buf := make([]byte, m.SizeBytes())
		m.MarshalBytes(buf)
		length, err := writer.Write(buf)
		return int64(length), err
	}

	// Construct a slice backed by dst's underlying memory.
	var buf []byte
	hdr := (*reflect.SliceHeader)(unsafe.Pointer(&buf))
	hdr.Data = uintptr(gohacks.Noescape(unsafe.Pointer(m)))
	hdr.Len = m.SizeBytes()
	hdr.Cap = m.SizeBytes()

	length, err := writer.Write(buf)
	// Since we bypassed the compiler's escape analysis, indicate that m
	// must live until the use above.
	runtime.KeepAlive(m) // escapes: replaced by intrinsic.
	return int64(length), err
}