mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-08-03 18:47:47 +00:00
Ayke van Laethem
b4c90f3677
This commit changes many things:
* Most interface-related operations are moved into an optimization
pass for more modularity. IR construction creates pseudo-calls which
are lowered in this pass.
* Type codes are assigned in this interface lowering pass, after DCE.
* Type codes are sorted by usage: types more often used in type
asserts are assigned lower numbers to ease jump table construction
during machine code generation.
* Interface assertions are optimized: they are replaced by constant
false, comparison against a constant, or a typeswitch with only
concrete types in the general case.
* Interface calls are replaced with unreachable, direct calls, or a
concrete type switch with direct calls depending on the number of
implementing types. This hopefully makes some interface patterns
zero-cost.
These changes lead to a ~0.5K reduction in code size on Cortex-M for
testdata/interface.go. It appears that a major cause for this is the
replacement of function pointers with direct calls, which are far more
susceptible to optimization. Also, not having a fixed global array of
function pointers greatly helps dead code elimination.
This change also makes future optimizations easier, like optimizations
on interface value comparisons.
61 lines
2.0 KiB
Go
61 lines
2.0 KiB
Go
package runtime
|
|
|
|
// This file implements Go interfaces.
|
|
//
|
|
// Interfaces are represented as a pair of {typecode, value}, where value can be
|
|
// anything (including non-pointers).
|
|
|
|
type _interface struct {
|
|
typecode uintptr
|
|
value *uint8
|
|
}
|
|
|
|
// Return true iff both interfaces are equal.
|
|
func interfaceEqual(x, y _interface) bool {
|
|
if x.typecode != y.typecode {
|
|
// Different dynamic type so always unequal.
|
|
return false
|
|
}
|
|
if x.typecode == 0 {
|
|
// Both interfaces are nil, so they are equal.
|
|
return true
|
|
}
|
|
// TODO: depends on reflection.
|
|
panic("unimplemented: interface equality")
|
|
}
|
|
|
|
// interfaceTypeAssert is called when a type assert without comma-ok still
|
|
// returns false.
|
|
func interfaceTypeAssert(ok bool) {
|
|
if !ok {
|
|
runtimePanic("type assert failed")
|
|
}
|
|
}
|
|
|
|
// The following declarations are only used during IR construction. They are
|
|
// lowered to inline IR in the interface lowering pass.
|
|
// See compiler/interface-lowering.go for details.
|
|
|
|
type interfaceMethodInfo struct {
|
|
signature *uint8 // external *i8 with a name identifying the Go function signature
|
|
funcptr *uint8 // bitcast from the actual function pointer
|
|
}
|
|
|
|
// Pseudo function call used while putting a concrete value in an interface,
|
|
// that must be lowered to a constant uintptr.
|
|
func makeInterface(typecode *uint8, methodSet *interfaceMethodInfo) uintptr
|
|
|
|
// Pseudo function call used during a type assert. It is used during interface
|
|
// lowering, to assign the lowest type numbers to the types with the most type
|
|
// asserts. Also, it is replaced with const false if this type assert can never
|
|
// happen.
|
|
func typeAssert(actualType uintptr, assertedType *uint8) bool
|
|
|
|
// Pseudo function call that returns whether a given type implements all methods
|
|
// of the given interface.
|
|
func interfaceImplements(typecode uintptr, interfaceMethodSet **uint8) bool
|
|
|
|
// Pseudo function that returns a function pointer to the method to call.
|
|
// See the interface lowering pass for how this is lowered to a real call.
|
|
func interfaceMethod(typecode uintptr, interfaceMethodSet **uint8, signature *uint8) *uint8
|