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

//go:build linux && (mips || mipsle) && gc

#include "textflag.h"

//
// System calls for mips, Linux
//

// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.

TEXT ·Syscall(SB),NOSPLIT,$0-28
	JMP syscall·Syscall(SB)

TEXT ·Syscall6(SB),NOSPLIT,$0-40
	JMP syscall·Syscall6(SB)

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

//go:build !js && !wasip1

// TODO(@musiol, @odeke-em): re-unify this entire file back into
// example.go when js/wasm gets an os.Pipe implementation
// and no longer needs this separation.

package testing

import (
	"fmt"
	"io"
	"os"
	"strings"
	"time"
)

func runExample(eg InternalExample) (ok bool) {
	if chatty.on {

//
// The zero value is a valid zero element.
type Scalar struct {
	// s is the scalar in the Montgomery domain, in the format of the
	// fiat-crypto implementation.
	s fiatScalarMontgomeryDomainFieldElement
}

// The field implementation in scalar_fiat.go is generated by the fiat-crypto
// project (https://github.com/mit-plv/fiat-crypto) at version v0.0.9 (23d2dbc)
// from a formally verified model.
//

var _ = Issue48396{Fd: 1, Bpf_fd: 2}

func main() {
	pass := true

	// The Go translation of bitfields should not have any of the
	// bitfield types. The order in which bitfields are laid out
	// in memory is implementation defined, so we can't easily
	// know how a bitfield should correspond to a Go type, even if
	// it appears to be aligned correctly.
	bitfieldType := reflect.TypeOf(bitfields{})
	check := func(name string) {

//

// See ../runtime/sys_linux_386.s for the reason why we always use int 0x80
// instead of the glibc-specific "CALL 0x10(GS)".
#define INVOKE_SYSCALL	INT	$0x80

// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.

TEXT ·Syscall(SB),NOSPLIT,$0-28
	JMP	syscall·Syscall(SB)

TEXT ·Syscall6(SB),NOSPLIT,$0-40
	JMP	syscall·Syscall6(SB)

package main

import (
	"database/sql"
)

// Collection generic interface which things can be added to.
type Collection[T any] interface {
	Add(T)
}

// Slice generic slice implementation of a Collection
type Slice[T any] []*T

func (s *Slice[T]) Add(t *T) {
	*s = append(*s, t)
}

type Scanner interface {
	Scan(...interface{}) error
}

type Mapper[T any] func(s Scanner, t T) error

	}

	return s, nil
}

// parseIPv4Slow parses and returns an IPv4 address in dotted quad
// form, e.g. "192.168.0.1". It is slow but easy to read, and the
// reference implementation against which we compare faster
// implementations for correctness.
func parseIPv4Slow(s string) (Addr, error) {
	fs := strings.Split(s, ".")
	if len(fs) != 4 {
		return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): invalid IP address", s)
	}

	dataLen := readPtr(hdr[ptrSize:])
	data, err := x.ReadData(dataAddr, dataLen)
	if err != nil || uint64(len(data)) < dataLen {
		return ""
	}
	return string(data)
}

// elfExe is the ELF implementation of the exe interface.
type elfExe struct {
	f *elf.File
}

func (x *elfExe) ReadData(addr, size uint64) ([]byte, error) {
	for _, prog := range x.f.Progs {

Interested users will have to evaluate for themselves whether the code
is useful for their own purposes.

---

This directory holds the core of the BoringCrypto implementation
as well as the build scripts for the module itself: syso/*.syso.

syso/goboringcrypto_linux_amd64.syso is built with:

	GOARCH=amd64 ./build.sh

syso/goboringcrypto_linux_arm64.syso is built with:

	// init-time configuration
	cmd := testenv.Command(t, testGo, "help", "documentation")
	// Unset GO111MODULE so that the 'go get' section matches
	// the default 'go get' implementation.
	cmd.Env = append(cmd.Environ(), "GO111MODULE=")
	cmd.Stderr = new(strings.Builder)
	out, err := cmd.Output()
	if err != nil {
		t.Fatalf("%v: %v\n%s", cmd, err, cmd.Stderr)
	}