package crc32

Import Path
	hash/crc32 (on golang.org and go.dev)

Dependency Relation
	imports 5 packages, and imported by one package

Involved Source Files
	   d➜ crc32.go
		Package crc32 implements the 32-bit cyclic redundancy check, or CRC-32,
		checksum. See https://en.wikipedia.org/wiki/Cyclic_redundancy_check for
		information.

		Polynomials are represented in LSB-first form also known as reversed representation.

		See https://en.wikipedia.org/wiki/Mathematics_of_cyclic_redundancy_checks#Reversed_representations_and_reciprocal_polynomials
		for information.

	      crc32_arm64.go
	      crc32_generic.go
	      crc32_arm64.s
Package-Level Type Names (total 3, in which 1 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Table ([...]T)
		Table is a 256-word table representing the polynomial for efficient processing.

		As Outputs Of (at least 2, in which 1 are exported)
			func MakeTable(poly uint32) *Table
			/* at least one unexported ... *//* at least one unexported: */
			func simpleMakeTable(poly uint32) *Table
		As Inputs Of (at least 6, in which 3 are exported)
			func Checksum(data []byte, tab *Table) uint32
			func New(tab *Table) hash.Hash32
			func Update(crc uint32, tab *Table, p []byte) uint32
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func simplePopulateTable(poly uint32, t *Table)
			func simpleUpdate(crc uint32, tab *Table, p []byte) uint32
			func tableSum(t *Table) uint32
		As Types Of (total 2, in which 1 are exported)
			  var IEEETable *Table
			/* one unexported ... *//* one unexported: */
			  var castagnoliTable *Table

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type digest (struct)
		digest represents the partial evaluation of a checksum.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			crc uint32
			tab *Table
		Methods (total 8, all are exported)
			(*T) BlockSize() int
			(*T) MarshalBinary() ([]byte, error)
			(*T) Reset()
			(*T) Size() int
			(*T) Sum(in []byte) []byte
			(*T) Sum32() uint32
			(*T) UnmarshalBinary(b []byte) error
			(*T) Write(p []byte) (n int, err error)
		Implements (at least 6, in which 5 are exported)
			*T : hash.Hash
			*T : hash.Hash32
			*T : encoding.BinaryMarshaler
			*T : encoding.BinaryUnmarshaler
			*T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*T : crypto/hmac.marshalable

	 type slicing8Table ([...]T)
		slicing8Table is array of 8 Tables, used by the slicing-by-8 algorithm.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func slicingMakeTable(poly uint32) *slicing8Table
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func slicingUpdate(crc uint32, tab *slicing8Table, p []byte) uint32
		As Types Of (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			  var castagnoliTable8 *slicing8Table
			  var ieeeTable8 *slicing8Table


Package-Level Functions (total 24, in which 6 are exported)

	 func Checksum(data []byte, tab *Table) uint32
		Checksum returns the CRC-32 checksum of data
		using the polynomial represented by the Table.

	 func ChecksumIEEE(data []byte) uint32
		ChecksumIEEE returns the CRC-32 checksum of data
		using the IEEE polynomial.

	 func MakeTable(poly uint32) *Table
		MakeTable returns a Table constructed from the specified polynomial.
		The contents of this Table must not be modified.

	 func New(tab *Table) hash.Hash32
		New creates a new hash.Hash32 computing the CRC-32 checksum using the
		polynomial represented by the Table. Its Sum method will lay the
		value out in big-endian byte order. The returned Hash32 also
		implements encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to
		marshal and unmarshal the internal state of the hash.

	 func NewIEEE() hash.Hash32
		NewIEEE creates a new hash.Hash32 computing the CRC-32 checksum using
		the IEEE polynomial. Its Sum method will lay the value out in
		big-endian byte order. The returned Hash32 also implements
		encoding.BinaryMarshaler and encoding.BinaryUnmarshaler to marshal
		and unmarshal the internal state of the hash.

	 func Update(crc uint32, tab *Table, p []byte) uint32
		Update returns the result of adding the bytes in p to the crc.

	/* 18 unexporteds ... *//* 18 unexporteds: */
	 func appendUint32(b []byte, x uint32) []byte
	 func archAvailableCastagnoli() bool
	 func archAvailableIEEE() bool
	 func archInitCastagnoli()
	 func archInitIEEE()
	 func archUpdateCastagnoli(crc uint32, p []byte) uint32
	 func archUpdateIEEE(crc uint32, p []byte) uint32
	 func castagnoliInit()
	 func castagnoliUpdate(crc uint32, p []byte) uint32
	 func ieeeInit()
	 func ieeeUpdate(crc uint32, p []byte) uint32
	 func readUint32(b []byte) uint32
	 func simpleMakeTable(poly uint32) *Table
		simpleMakeTable allocates and constructs a Table for the specified
		polynomial. The table is suitable for use with the simple algorithm
		(simpleUpdate).

	 func simplePopulateTable(poly uint32, t *Table)
		simplePopulateTable constructs a Table for the specified polynomial, suitable
		for use with simpleUpdate.

	 func simpleUpdate(crc uint32, tab *Table, p []byte) uint32
		simpleUpdate uses the simple algorithm to update the CRC, given a table that
		was previously computed using simpleMakeTable.

	 func slicingMakeTable(poly uint32) *slicing8Table
		slicingMakeTable constructs a slicing8Table for the specified polynomial. The
		table is suitable for use with the slicing-by-8 algorithm (slicingUpdate).

	 func slicingUpdate(crc uint32, tab *slicing8Table, p []byte) uint32
		slicingUpdate uses the slicing-by-8 algorithm to update the CRC, given a
		table that was previously computed using slicingMakeTable.

	 func tableSum(t *Table) uint32
		tableSum returns the IEEE checksum of table t.


Package-Level Variables (total 11, in which 1 are exported)

	  var IEEETable *Table
		IEEETable is the table for the IEEE polynomial.

	/* 10 unexporteds ... *//* 10 unexporteds: */
	  var castagnoliArchImpl bool
	  var castagnoliOnce sync.Once
	  var castagnoliTable *Table
		castagnoliTable points to a lazily initialized Table for the Castagnoli
		polynomial. MakeTable will always return this value when asked to make a
		Castagnoli table so we can compare against it to find when the caller is
		using this polynomial.

	  var castagnoliTable8 *slicing8Table
	  var haveCastagnoli uint32
	  var ieeeArchImpl bool
	  var ieeeOnce sync.Once
	  var ieeeTable8 *slicing8Table
		ieeeTable8 is the slicing8Table for IEEE

	  var updateCastagnoli (crc uint32, p []byte) uint32
	  var updateIEEE (crc uint32, p []byte) uint32
Package-Level Constants (total 7, in which 4 are exported)

	const Castagnoli = 2197175160
		Castagnoli's polynomial, used in iSCSI.
		Has better error detection characteristics than IEEE.
		https://dx.doi.org/10.1109/26.231911

	const IEEE = 3988292384
		IEEE is by far and away the most common CRC-32 polynomial.
		Used by ethernet (IEEE 802.3), v.42, fddi, gzip, zip, png, ...

	const Koopman = 3945912366
		Koopman's polynomial.
		Also has better error detection characteristics than IEEE.
		https://dx.doi.org/10.1109/DSN.2002.1028931

	const Size = 4
		The size of a CRC-32 checksum in bytes.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const magic = "crc\x01"
	const marshaledSize int = 12
	const slicing8Cutoff = 16
		Use slicing-by-8 when payload >= this value.

The pages are generated with Golds v0.2.8-preview. (GOOS=darwin GOARCH=arm64)