compare

func EqCanPanic ¶

func EqCanPanic(t *types.Type) bool

EqCanPanic reports whether == on type t could panic (has an interface somewhere). t must be comparable.

func EqInterface ¶

func EqInterface(s, t ir.Node) (eqtab *ir.BinaryExpr, eqdata *ir.CallExpr)

EqInterface returns the nodes

s.tab == t.tab (or s.typ == t.typ, as appropriate)

and

ifaceeq(s.tab, s.data, t.data) (or efaceeq(s.typ, s.data, t.data), as appropriate)

which can be used to construct interface equality comparison. eqtab must be evaluated before eqdata, and shortcircuiting is required.

func EqString ¶

func EqString(s, t ir.Node) (eqlen *ir.BinaryExpr, eqmem *ir.CallExpr)

EqString returns the nodes

len(s) == len(t)

and

memequal(s.ptr, t.ptr, len(s))

which can be used to construct string equality comparison. eqlen must be evaluated before eqmem, and shortcircuiting is required.

func EqStruct ¶

func EqStruct(t *types.Type, np, nq ir.Node) ([]ir.Node, bool)

EqStruct compares two structs np and nq for equality. It works by building a list of boolean conditions to satisfy. Conditions must be evaluated in the returned order and properly short-circuited by the caller. The first return value is the flattened list of conditions, the second value is a boolean indicating whether any of the comparisons could panic.

func EqStructCost ¶ added in go1.20

func EqStructCost(t *types.Type) int64

EqStructCost returns the cost of an equality comparison of two structs.

The cost is determined using an algorithm which takes into consideration the size of the registers in the current architecture and the size of the memory-only fields in the struct.

func IsRegularMemory ¶

func IsRegularMemory(t *types.Type) bool

IsRegularMemory reports whether t can be compared/hashed as regular memory.

func Memrun ¶

func Memrun(t *types.Type, start int) (size int64, next int)

Memrun finds runs of struct fields for which memory-only algs are appropriate. t is the parent struct type, and start is the field index at which to start the run. size is the length in bytes of the memory included in the run. next is the index just after the end of the memory run.