mirror of
https://github.com/tinygo-org/tinygo.git
synced 2026-07-26 06:38:42 +00:00
Jake Bailey
9e7d89d4d5
LLVM ComputeValueVTs recursively expands arrays and structs into one value type per scalar leaf. SelectionDAG call lowering allocates data structures proportional to this count, which makes very large values exhaust memory or crash LLVM. Count scalar leaves and use pointers for internal parameters and results when the count exceeds 1024. A result pointer is the first parameter, and aggregate parameters point to read-only memory. Exported function types are unchanged. Keep these SSA values in memory and copy them with memcpy when needed. Handle calls, interfaces, maps, channels, selects, defers, goroutines, phis, and multiple results. Update the expected compiler IR and re-enable the native compress/flate tests.
1349 lines
48 KiB
Go
1349 lines
48 KiB
Go
package compiler
|
|
|
|
// This file transforms interface-related instructions (*ssa.MakeInterface,
|
|
// *ssa.TypeAssert, calls on interface types) to an intermediate IR form, to be
|
|
// lowered to the final form by the interface lowering pass. See
|
|
// interface-lowering.go for more details.
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"go/token"
|
|
"go/types"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"golang.org/x/tools/go/ssa"
|
|
"tinygo.org/x/go-llvm"
|
|
)
|
|
|
|
// numMethodHasMethodSet is a flag in bit 15 of the numMethod field (uint16) in
|
|
// Named, Pointer, and Struct type descriptors. When set, an inline method set
|
|
// is present in the type descriptor. Must match the constant in
|
|
// src/internal/reflectlite/type.go.
|
|
const numMethodHasMethodSet = 0x8000
|
|
|
|
// Type kinds for basic types.
|
|
// They must match the constants for the Kind type in src/reflect/type.go.
|
|
var basicTypes = [...]uint8{
|
|
types.Bool: 1,
|
|
types.Int: 2,
|
|
types.Int8: 3,
|
|
types.Int16: 4,
|
|
types.Int32: 5,
|
|
types.Int64: 6,
|
|
types.Uint: 7,
|
|
types.Uint8: 8,
|
|
types.Uint16: 9,
|
|
types.Uint32: 10,
|
|
types.Uint64: 11,
|
|
types.Uintptr: 12,
|
|
types.Float32: 13,
|
|
types.Float64: 14,
|
|
types.Complex64: 15,
|
|
types.Complex128: 16,
|
|
types.String: 17,
|
|
types.UnsafePointer: 18,
|
|
}
|
|
|
|
// These must also match the constants for the Kind type in src/reflect/type.go.
|
|
const (
|
|
typeKindChan = 19
|
|
typeKindInterface = 20
|
|
typeKindPointer = 21
|
|
typeKindSlice = 22
|
|
typeKindArray = 23
|
|
typeKindSignature = 24
|
|
typeKindMap = 25
|
|
typeKindStruct = 26
|
|
)
|
|
|
|
// Flags stored in the first byte of the struct field byte array. Must be kept
|
|
// up to date with src/reflect/type.go.
|
|
const (
|
|
structFieldFlagAnonymous = 1 << iota
|
|
structFieldFlagHasTag
|
|
structFieldFlagIsExported
|
|
structFieldFlagIsEmbedded
|
|
)
|
|
|
|
type reflectChanDir int
|
|
|
|
const (
|
|
refRecvDir reflectChanDir = 1 << iota // <-chan
|
|
refSendDir // chan<-
|
|
refBothDir = refRecvDir | refSendDir // chan
|
|
)
|
|
|
|
// createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
|
|
// It tries to put the type in the interface value, but if that's not possible,
|
|
// it will do an allocation of the right size and put that in the interface
|
|
// value field.
|
|
//
|
|
// An interface value is a {typecode, value} tuple named runtime._interface.
|
|
func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
|
|
itfValue := b.emitPointerPack([]llvm.Value{val}, pos)
|
|
return b.createMakeInterfaceFromPointer(itfValue, typ)
|
|
}
|
|
|
|
func (b *builder) createMakeInterfaceFromPointer(itfValue llvm.Value, typ types.Type) llvm.Value {
|
|
itfType := b.getTypeCode(typ)
|
|
itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
|
|
itf = b.CreateInsertValue(itf, itfType, 0, "")
|
|
itf = b.CreateInsertValue(itf, itfValue, 1, "")
|
|
return itf
|
|
}
|
|
|
|
// extractValueFromInterface extract the value from an interface value
|
|
// (runtime._interface) under the assumption that it is of the type given in
|
|
// llvmType. The behavior is undefined if the interface is nil or llvmType
|
|
// doesn't match the underlying type of the interface.
|
|
func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type) llvm.Value {
|
|
valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
|
|
if b.isIndirectAggregate(llvmType) {
|
|
return valuePtr
|
|
}
|
|
return b.emitPointerUnpack(valuePtr, []llvm.Type{llvmType})[0]
|
|
}
|
|
|
|
func (b *builder) extractValuePointerFromInterface(itf llvm.Value) llvm.Value {
|
|
return b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
|
|
}
|
|
|
|
func (c *compilerContext) pkgPathPtr(pkgpath string) llvm.Value {
|
|
pkgpathName := "reflect/types.type.pkgpath.empty"
|
|
if pkgpath != "" {
|
|
pkgpathName = "reflect/types.type.pkgpath:" + pkgpath
|
|
}
|
|
|
|
pkgpathGlobal := c.mod.NamedGlobal(pkgpathName)
|
|
if pkgpathGlobal.IsNil() {
|
|
pkgpathInitializer := c.ctx.ConstString(pkgpath+"\x00", false)
|
|
pkgpathGlobal = llvm.AddGlobal(c.mod, pkgpathInitializer.Type(), pkgpathName)
|
|
pkgpathGlobal.SetInitializer(pkgpathInitializer)
|
|
pkgpathGlobal.SetAlignment(1)
|
|
pkgpathGlobal.SetUnnamedAddr(true)
|
|
pkgpathGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
pkgpathGlobal.SetGlobalConstant(true)
|
|
}
|
|
pkgPathPtr := llvm.ConstGEP(pkgpathGlobal.GlobalValueType(), pkgpathGlobal, []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int32Type(), 0, false),
|
|
llvm.ConstInt(c.ctx.Int32Type(), 0, false),
|
|
})
|
|
|
|
return pkgPathPtr
|
|
}
|
|
|
|
// getTypeCode returns a reference to a type code.
|
|
// A type code is a pointer to a constant global that describes the type.
|
|
// This function returns a pointer to the 'kind' field (which might not be the
|
|
// first field in the struct).
|
|
func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
|
|
// Resolve alias types: alias types are resolved at compile time.
|
|
typ = types.Unalias(typ)
|
|
|
|
ms := c.program.MethodSets.MethodSet(typ)
|
|
hasMethodSet := ms.Len() != 0
|
|
_, isInterface := typ.Underlying().(*types.Interface)
|
|
if isInterface {
|
|
hasMethodSet = false
|
|
}
|
|
|
|
// As defined in https://pkg.go.dev/reflect#Type:
|
|
// NumMethod returns the number of methods accessible using Method.
|
|
// For a non-interface type, it returns the number of exported methods.
|
|
// For an interface type, it returns the number of exported and unexported methods.
|
|
var numMethods int
|
|
for method := range ms.Methods() {
|
|
if isInterface || method.Obj().Exported() {
|
|
numMethods++
|
|
}
|
|
}
|
|
|
|
// Short-circuit all the global pointer logic here for pointers to pointers.
|
|
if typ, ok := typ.(*types.Pointer); ok {
|
|
if _, ok := typ.Elem().(*types.Pointer); ok {
|
|
// For a pointer to a pointer, we just increase the pointer by 1
|
|
ptr := c.getTypeCode(typ.Elem())
|
|
// if the type is already *****T or higher, we can't make it.
|
|
if typstr := typ.String(); strings.HasPrefix(typstr, "*****") {
|
|
c.addError(token.NoPos, fmt.Sprintf("too many levels of pointers for typecode: %s", typstr))
|
|
}
|
|
return llvm.ConstGEP(c.ctx.Int8Type(), ptr, []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int32Type(), 1, false),
|
|
})
|
|
}
|
|
}
|
|
|
|
typeCodeName, isLocal := c.getTypeCodeName(typ)
|
|
globalName := "reflect/types.type:" + typeCodeName
|
|
var global llvm.Value
|
|
if isLocal {
|
|
// This type is a named type inside a function, like this:
|
|
//
|
|
// func foo() any {
|
|
// type named int
|
|
// return named(0)
|
|
// }
|
|
if obj := c.interfaceTypes.At(typ); obj != nil {
|
|
global = obj.(llvm.Value)
|
|
}
|
|
} else {
|
|
// Regular type (named or otherwise).
|
|
global = c.mod.NamedGlobal(globalName)
|
|
}
|
|
if global.IsNil() {
|
|
var typeFields []llvm.Value
|
|
// Define the type fields. These must match the structs in
|
|
// src/reflect/type.go (ptrType, arrayType, etc). See the comment at the
|
|
// top of src/reflect/type.go for more information on the layout of these structs.
|
|
typeFieldTypes := []*types.Var{
|
|
types.NewVar(token.NoPos, nil, "kind", types.Typ[types.Int8]),
|
|
}
|
|
// Compute the method set value for types that support methods.
|
|
var methods []*types.Func
|
|
for method := range ms.Methods() {
|
|
methods = append(methods, method.Obj().(*types.Func))
|
|
}
|
|
methodSetType := types.NewStruct([]*types.Var{
|
|
types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
|
|
types.NewVar(token.NoPos, nil, "methods", types.NewArray(types.Typ[types.UnsafePointer], int64(len(methods)))),
|
|
}, nil)
|
|
methodSetValue := c.getMethodSetValue(methods)
|
|
switch typ := typ.(type) {
|
|
case *types.Basic:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
)
|
|
case *types.Named:
|
|
name := typ.Obj().Name()
|
|
var pkgname string
|
|
if pkg := typ.Obj().Pkg(); pkg != nil {
|
|
pkgname = pkg.Name()
|
|
}
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "underlying", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "pkgpath", types.Typ[types.UnsafePointer]),
|
|
)
|
|
if len(methods) > 0 {
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "methods", methodSetType),
|
|
)
|
|
}
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "name", types.NewArray(types.Typ[types.Int8], int64(len(pkgname)+1+len(name)+1))),
|
|
)
|
|
case *types.Chan:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]), // reuse for select chan direction
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
|
|
)
|
|
case *types.Slice:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
|
|
)
|
|
case *types.Pointer:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
|
|
)
|
|
if len(methods) > 0 {
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "methods", methodSetType),
|
|
)
|
|
}
|
|
case *types.Array:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
|
|
types.NewVar(token.NoPos, nil, "sliceOf", types.Typ[types.UnsafePointer]),
|
|
)
|
|
case *types.Map:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "keyType", types.Typ[types.UnsafePointer]),
|
|
)
|
|
case *types.Struct:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "pkgpath", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "size", types.Typ[types.Uint32]),
|
|
types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
|
|
types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
|
|
)
|
|
if len(methods) > 0 {
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "methods", methodSetType),
|
|
)
|
|
}
|
|
case *types.Interface:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
types.NewVar(token.NoPos, nil, "methods", methodSetType),
|
|
)
|
|
case *types.Signature:
|
|
typeFieldTypes = append(typeFieldTypes,
|
|
types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
|
|
)
|
|
// TODO: signature params and return values
|
|
}
|
|
if hasMethodSet {
|
|
// This method set is appended at the start of the struct. It is
|
|
// removed in the interface lowering pass.
|
|
// TODO: don't remove these and instead do what upstream Go is doing
|
|
// instead. See: https://research.swtch.com/interfaces. This can
|
|
// likely be optimized in LLVM using
|
|
// https://llvm.org/docs/TypeMetadata.html.
|
|
typeFieldTypes = append([]*types.Var{
|
|
types.NewVar(token.NoPos, nil, "methodSet", types.Typ[types.UnsafePointer]),
|
|
}, typeFieldTypes...)
|
|
}
|
|
globalType := types.NewStruct(typeFieldTypes, nil)
|
|
global = llvm.AddGlobal(c.mod, c.getLLVMType(globalType), globalName)
|
|
if isLocal {
|
|
c.interfaceTypes.Set(typ, global)
|
|
}
|
|
metabyte := getTypeKind(typ)
|
|
|
|
// Precompute these so we don't have to calculate them at runtime.
|
|
if types.Comparable(typ) {
|
|
metabyte |= 1 << 6
|
|
}
|
|
|
|
if hashmapIsBinaryKey(typ) {
|
|
metabyte |= 1 << 7
|
|
}
|
|
|
|
switch typ := typ.(type) {
|
|
case *types.Basic:
|
|
typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
|
|
case *types.Named:
|
|
name := typ.Obj().Name()
|
|
var pkgpath string
|
|
var pkgname string
|
|
if pkg := typ.Obj().Pkg(); pkg != nil {
|
|
pkgpath = pkg.Path()
|
|
pkgname = pkg.Name()
|
|
}
|
|
pkgPathPtr := c.pkgPathPtr(pkgpath)
|
|
namedNumMethods := uint64(numMethods)
|
|
if namedNumMethods&numMethodHasMethodSet != 0 {
|
|
panic("numMethods overflow: too many exported methods on named type " + name)
|
|
}
|
|
if len(methods) > 0 {
|
|
namedNumMethods |= numMethodHasMethodSet
|
|
}
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), namedNumMethods, false), // numMethods
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
c.getTypeCode(typ.Underlying()), // underlying
|
|
pkgPathPtr, // pkgpath pointer
|
|
}
|
|
if len(methods) > 0 {
|
|
typeFields = append(typeFields, methodSetValue) // methods
|
|
}
|
|
typeFields = append(typeFields, c.ctx.ConstString(pkgname+"."+name+"\x00", false)) // name
|
|
metabyte |= 1 << 5 // "named" flag
|
|
case *types.Chan:
|
|
var dir reflectChanDir
|
|
switch typ.Dir() {
|
|
case types.SendRecv:
|
|
dir = refBothDir
|
|
case types.RecvOnly:
|
|
dir = refRecvDir
|
|
case types.SendOnly:
|
|
dir = refSendDir
|
|
}
|
|
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), uint64(dir), false), // actually channel direction
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
c.getTypeCode(typ.Elem()), // elementType
|
|
}
|
|
case *types.Slice:
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
c.getTypeCode(typ.Elem()), // elementType
|
|
}
|
|
case *types.Pointer:
|
|
ptrNumMethods := uint64(numMethods)
|
|
if ptrNumMethods&numMethodHasMethodSet != 0 {
|
|
panic("numMethods overflow: too many exported methods on pointer type")
|
|
}
|
|
if len(methods) > 0 {
|
|
ptrNumMethods |= numMethodHasMethodSet
|
|
}
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), ptrNumMethods, false), // numMethods
|
|
c.getTypeCode(typ.Elem()),
|
|
}
|
|
if len(methods) > 0 {
|
|
typeFields = append(typeFields, methodSetValue)
|
|
}
|
|
case *types.Array:
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
c.getTypeCode(typ.Elem()), // elementType
|
|
llvm.ConstInt(c.uintptrType, uint64(typ.Len()), false), // length
|
|
c.getTypeCode(types.NewSlice(typ.Elem())), // slicePtr
|
|
}
|
|
case *types.Map:
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
c.getTypeCode(typ.Elem()), // elem
|
|
c.getTypeCode(typ.Key()), // key
|
|
}
|
|
case *types.Struct:
|
|
var pkgpath string
|
|
if typ.NumFields() > 0 {
|
|
if pkg := typ.Field(0).Pkg(); pkg != nil {
|
|
pkgpath = pkg.Path()
|
|
}
|
|
}
|
|
pkgPathPtr := c.pkgPathPtr(pkgpath)
|
|
|
|
llvmStructType := c.getLLVMType(typ)
|
|
size := c.targetData.TypeStoreSize(llvmStructType)
|
|
structNumMethods := uint64(numMethods)
|
|
if structNumMethods&numMethodHasMethodSet != 0 {
|
|
panic("numMethods overflow: too many exported methods on struct type")
|
|
}
|
|
if len(methods) > 0 {
|
|
structNumMethods |= numMethodHasMethodSet
|
|
}
|
|
typeFields = []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int16Type(), structNumMethods, false), // numMethods
|
|
c.getTypeCode(types.NewPointer(typ)), // ptrTo
|
|
pkgPathPtr,
|
|
llvm.ConstInt(c.ctx.Int32Type(), uint64(size), false), // size
|
|
llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
|
|
}
|
|
structFieldType := c.getLLVMRuntimeType("structField")
|
|
|
|
var fields []llvm.Value
|
|
for i := 0; i < typ.NumFields(); i++ {
|
|
field := typ.Field(i)
|
|
offset := c.targetData.ElementOffset(llvmStructType, i)
|
|
var flags uint8
|
|
if field.Anonymous() {
|
|
flags |= structFieldFlagAnonymous
|
|
}
|
|
if typ.Tag(i) != "" {
|
|
flags |= structFieldFlagHasTag
|
|
}
|
|
if token.IsExported(field.Name()) {
|
|
flags |= structFieldFlagIsExported
|
|
}
|
|
if field.Embedded() {
|
|
flags |= structFieldFlagIsEmbedded
|
|
}
|
|
|
|
var offsBytes [binary.MaxVarintLen32]byte
|
|
offLen := binary.PutUvarint(offsBytes[:], offset)
|
|
|
|
data := string(flags) + string(offsBytes[:offLen]) + field.Name() + "\x00"
|
|
if typ.Tag(i) != "" {
|
|
if len(typ.Tag(i)) > 0xff {
|
|
c.addError(field.Pos(), fmt.Sprintf("struct tag is %d bytes which is too long, max is 255", len(typ.Tag(i))))
|
|
}
|
|
data += string([]byte{byte(len(typ.Tag(i)))}) + typ.Tag(i)
|
|
}
|
|
dataInitializer := c.ctx.ConstString(data, false)
|
|
dataGlobal := llvm.AddGlobal(c.mod, dataInitializer.Type(), globalName+"."+field.Name())
|
|
dataGlobal.SetInitializer(dataInitializer)
|
|
dataGlobal.SetAlignment(1)
|
|
dataGlobal.SetUnnamedAddr(true)
|
|
dataGlobal.SetLinkage(llvm.InternalLinkage)
|
|
dataGlobal.SetGlobalConstant(true)
|
|
fieldType := c.getTypeCode(field.Type())
|
|
fields = append(fields, llvm.ConstNamedStruct(structFieldType, []llvm.Value{
|
|
fieldType,
|
|
llvm.ConstGEP(dataGlobal.GlobalValueType(), dataGlobal, []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int32Type(), 0, false),
|
|
llvm.ConstInt(c.ctx.Int32Type(), 0, false),
|
|
}),
|
|
}))
|
|
}
|
|
typeFields = append(typeFields, llvm.ConstArray(structFieldType, fields))
|
|
if len(methods) > 0 {
|
|
typeFields = append(typeFields, methodSetValue)
|
|
}
|
|
case *types.Interface:
|
|
typeFields = []llvm.Value{
|
|
c.getTypeCode(types.NewPointer(typ)),
|
|
methodSetValue,
|
|
}
|
|
case *types.Signature:
|
|
typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
|
|
// TODO: params, return values, etc
|
|
}
|
|
// Prepend metadata byte.
|
|
typeFields = append([]llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int8Type(), uint64(metabyte), false),
|
|
}, typeFields...)
|
|
if hasMethodSet {
|
|
typeFields = append([]llvm.Value{
|
|
c.getTypeMethodSet(typ),
|
|
}, typeFields...)
|
|
}
|
|
alignment := max(c.targetData.TypeAllocSize(c.dataPtrType), 4)
|
|
globalValue := c.ctx.ConstStruct(typeFields, false)
|
|
global.SetInitializer(globalValue)
|
|
if isLocal {
|
|
global.SetLinkage(llvm.InternalLinkage)
|
|
} else {
|
|
global.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
}
|
|
global.SetGlobalConstant(true)
|
|
global.SetAlignment(int(alignment))
|
|
if c.Debug {
|
|
file := c.getDIFile("<Go type>")
|
|
diglobal := c.dibuilder.CreateGlobalVariableExpression(file, llvm.DIGlobalVariableExpression{
|
|
Name: "type " + typ.String(),
|
|
File: file,
|
|
Line: 1,
|
|
Type: c.getDIType(globalType),
|
|
LocalToUnit: false,
|
|
Expr: c.dibuilder.CreateExpression(nil),
|
|
AlignInBits: uint32(alignment * 8),
|
|
})
|
|
global.AddMetadata(0, diglobal)
|
|
}
|
|
}
|
|
offset := uint64(0)
|
|
if hasMethodSet {
|
|
// The pointer to the method set is always the first element of the
|
|
// global (if there is a method set). However, the pointer we return
|
|
// should point to the 'kind' field not the method set.
|
|
offset = 1
|
|
}
|
|
return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
|
|
llvm.ConstInt(c.ctx.Int32Type(), 0, false),
|
|
llvm.ConstInt(c.ctx.Int32Type(), offset, false),
|
|
})
|
|
}
|
|
|
|
// getTypeKind returns the type kind for the given type, as defined by
|
|
// reflect.Kind.
|
|
func getTypeKind(t types.Type) uint8 {
|
|
switch t := t.Underlying().(type) {
|
|
case *types.Basic:
|
|
return basicTypes[t.Kind()]
|
|
case *types.Chan:
|
|
return typeKindChan
|
|
case *types.Interface:
|
|
return typeKindInterface
|
|
case *types.Pointer:
|
|
return typeKindPointer
|
|
case *types.Slice:
|
|
return typeKindSlice
|
|
case *types.Array:
|
|
return typeKindArray
|
|
case *types.Signature:
|
|
return typeKindSignature
|
|
case *types.Map:
|
|
return typeKindMap
|
|
case *types.Struct:
|
|
return typeKindStruct
|
|
default:
|
|
panic("unknown type")
|
|
}
|
|
}
|
|
|
|
var basicTypeNames = [...]string{
|
|
types.Bool: "bool",
|
|
types.Int: "int",
|
|
types.Int8: "int8",
|
|
types.Int16: "int16",
|
|
types.Int32: "int32",
|
|
types.Int64: "int64",
|
|
types.Uint: "uint",
|
|
types.Uint8: "uint8",
|
|
types.Uint16: "uint16",
|
|
types.Uint32: "uint32",
|
|
types.Uint64: "uint64",
|
|
types.Uintptr: "uintptr",
|
|
types.Float32: "float32",
|
|
types.Float64: "float64",
|
|
types.Complex64: "complex64",
|
|
types.Complex128: "complex128",
|
|
types.String: "string",
|
|
types.UnsafePointer: "unsafe.Pointer",
|
|
}
|
|
|
|
// getTypeCodeName returns a name for this type that can be used in the
|
|
// interface lowering pass to assign type codes as expected by the reflect
|
|
// package. See getTypeCodeNum.
|
|
//
|
|
// isLocal is true when the type is declared inside a function body.
|
|
// Such types need a per-declaration (or per instantiation) suffix
|
|
// because their printed names are not unique.
|
|
//
|
|
// Ordinary function-local types (TypeName.Parent() != nil) are
|
|
// disambiguated lazily from their declaration position: every
|
|
// declaration in the package has a distinct (file, line, column)
|
|
// triple, and the position is taken un-//line-adjusted so it is
|
|
// stable across builds. Such types are only nameable inside their
|
|
// declaring package, so the name does not need to agree with anything
|
|
// computed in another package.
|
|
//
|
|
// Synthetic locals (TypeName.Parent() == nil), produced by generic
|
|
// instantiation, are pre-registered by scanLocalTypes because their
|
|
// names must agree across packages that materialize the same instance.
|
|
func (c *compilerContext) getTypeCodeName(t types.Type) (name string, isLocal bool) {
|
|
switch t := types.Unalias(t).(type) {
|
|
case *types.Named:
|
|
tn := t.Obj()
|
|
if tn.Pkg() == nil || tn.Parent() == tn.Pkg().Scope() {
|
|
name := tn.Name()
|
|
if tn.Pkg() != nil {
|
|
name = tn.Pkg().Path() + "." + name
|
|
}
|
|
isLocal := false
|
|
if targs := t.TypeArgs(); targs.Len() != 0 {
|
|
parts := make([]string, targs.Len())
|
|
for i := range parts {
|
|
var local bool
|
|
parts[i], local = c.getTypeCodeName(targs.At(i))
|
|
isLocal = isLocal || local
|
|
}
|
|
name += "[" + strings.Join(parts, ",") + "]"
|
|
}
|
|
return "named:" + name, isLocal
|
|
}
|
|
if tn.Parent() != nil {
|
|
// Ordinary function-local type. Use the un-//line-adjusted
|
|
// declaration position as the disambiguator.
|
|
pos := c.program.Fset.PositionFor(tn.Pos(), false)
|
|
return fmt.Sprintf("named:%s$%s:%d:%d", t.String(), filepath.Base(pos.Filename), pos.Line, pos.Column), true
|
|
}
|
|
// Synthetic local from generic instantiation: must have been
|
|
// pre-registered by scanLocalTypes.
|
|
v := c.localTypeNames.At(t)
|
|
if v == nil {
|
|
panic("compiler: synthetic local type " + tn.Name() + " was not registered by scanLocalTypes")
|
|
}
|
|
return "named:" + v.(string), true
|
|
case *types.Array:
|
|
s, isLocal := c.getTypeCodeName(t.Elem())
|
|
return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + s, isLocal
|
|
case *types.Basic:
|
|
return "basic:" + basicTypeNames[t.Kind()], false
|
|
case *types.Chan:
|
|
s, isLocal := c.getTypeCodeName(t.Elem())
|
|
var dir string
|
|
switch t.Dir() {
|
|
case types.SendOnly:
|
|
dir = "s:"
|
|
case types.RecvOnly:
|
|
dir = "r:"
|
|
case types.SendRecv:
|
|
dir = "sr:"
|
|
}
|
|
|
|
return "chan:" + dir + s, isLocal
|
|
case *types.Interface:
|
|
isLocal := false
|
|
methods := make([]string, t.NumMethods())
|
|
for i := 0; i < t.NumMethods(); i++ {
|
|
name := t.Method(i).Name()
|
|
if !token.IsExported(name) {
|
|
name = t.Method(i).Pkg().Path() + "." + name
|
|
}
|
|
s, local := c.getTypeCodeName(t.Method(i).Type())
|
|
if local {
|
|
isLocal = true
|
|
}
|
|
methods[i] = name + ":" + s
|
|
}
|
|
return "interface:" + "{" + strings.Join(methods, ",") + "}", isLocal
|
|
case *types.Map:
|
|
keyType, keyLocal := c.getTypeCodeName(t.Key())
|
|
elemType, elemLocal := c.getTypeCodeName(t.Elem())
|
|
return "map:" + "{" + keyType + "," + elemType + "}", keyLocal || elemLocal
|
|
case *types.Pointer:
|
|
s, isLocal := c.getTypeCodeName(t.Elem())
|
|
return "pointer:" + s, isLocal
|
|
case *types.Signature:
|
|
isLocal := false
|
|
params := make([]string, t.Params().Len())
|
|
for i := 0; i < t.Params().Len(); i++ {
|
|
s, local := c.getTypeCodeName(t.Params().At(i).Type())
|
|
if local {
|
|
isLocal = true
|
|
}
|
|
params[i] = s
|
|
}
|
|
results := make([]string, t.Results().Len())
|
|
for i := 0; i < t.Results().Len(); i++ {
|
|
s, local := c.getTypeCodeName(t.Results().At(i).Type())
|
|
if local {
|
|
isLocal = true
|
|
}
|
|
results[i] = s
|
|
}
|
|
return "func:" + "{" + strings.Join(params, ",") + "}{" + strings.Join(results, ",") + "}", isLocal
|
|
case *types.Slice:
|
|
s, isLocal := c.getTypeCodeName(t.Elem())
|
|
return "slice:" + s, isLocal
|
|
case *types.Struct:
|
|
elems := make([]string, t.NumFields())
|
|
isLocal := false
|
|
for i := 0; i < t.NumFields(); i++ {
|
|
embedded := ""
|
|
if t.Field(i).Embedded() {
|
|
embedded = "#"
|
|
}
|
|
s, local := c.getTypeCodeName(t.Field(i).Type())
|
|
if local {
|
|
isLocal = true
|
|
}
|
|
elems[i] = embedded + t.Field(i).Name() + ":" + s
|
|
if t.Tag(i) != "" {
|
|
elems[i] += "`" + t.Tag(i) + "`"
|
|
}
|
|
}
|
|
return "struct:" + "{" + strings.Join(elems, ",") + "}", isLocal
|
|
default:
|
|
panic("unknown type: " + t.String())
|
|
}
|
|
}
|
|
|
|
// scanLocalTypes assigns names to every synthetic *types.TypeName
|
|
// (TypeName.Parent() == nil) reachable from this package and stores
|
|
// them in c.localTypeNames.
|
|
//
|
|
// Synthetic TypeNames are produced by generic instantiation: two
|
|
// instantiations of the same generic function (e.g. F[int] and
|
|
// F[string]) produce TypeNames with the same printed name and the
|
|
// same source position, so each is named with the enclosing instance's
|
|
// canonical function name as prefix. The function name encodes the type
|
|
// arguments, matching Go's runtime behavior, where F[int].Inner and
|
|
// F[string].Inner are distinct types even when Inner does not mention
|
|
// the type parameter.
|
|
//
|
|
// A given instance may be materialized by several packages (the body
|
|
// of F[int] is compiled in every package that calls F[int]); its
|
|
// reflect/types.type:* global has LinkOnceODRLinkage and is merged by
|
|
// name at link time. The chosen name therefore depends only on
|
|
// intrinsic SSA properties (the canonical function name and raw token.Pos),
|
|
// so any package compiling the same instance produces the same
|
|
// identifier.
|
|
//
|
|
// Ordinary function-local TypeNames (TypeName.Parent() != nil) are
|
|
// not handled here: they are nameable only inside their declaring
|
|
// package, and getTypeCodeName derives a stable per-declaration name
|
|
// for them directly from their source position.
|
|
func (c *compilerContext) scanLocalTypes(ssaPkg *ssa.Package) {
|
|
// Locate every generic instance reachable from this package
|
|
// (including instances declared in imported packages and any
|
|
// function reached through an instance subtree).
|
|
var instances []*ssa.Function
|
|
seen := map[*ssa.Function]struct{}{}
|
|
var walk func(fn *ssa.Function, inInstance bool)
|
|
walk = func(fn *ssa.Function, inInstance bool) {
|
|
if fn == nil {
|
|
return
|
|
}
|
|
if _, ok := seen[fn]; ok {
|
|
return
|
|
}
|
|
// fn belongs to an instance subtree if it is itself an
|
|
// instantiation or if we reached it from one.
|
|
//
|
|
// len(TypeArgs()) is used instead of fn.Origin() because
|
|
// Origin() may call Build() on fn's declaring package, which
|
|
// would defeat per-package compilation.
|
|
isInstanceRoot := len(fn.TypeArgs()) > 0
|
|
if !isInstanceRoot && !inInstance && fn.Pkg != ssaPkg {
|
|
return
|
|
}
|
|
if fn.Blocks == nil && fn.AnonFuncs == nil {
|
|
return
|
|
}
|
|
seen[fn] = struct{}{}
|
|
isInInstance := inInstance || isInstanceRoot
|
|
if isInInstance {
|
|
instances = append(instances, fn)
|
|
}
|
|
for _, anon := range fn.AnonFuncs {
|
|
walk(anon, isInInstance)
|
|
}
|
|
var ops [10]*ssa.Value
|
|
for _, b := range fn.Blocks {
|
|
for _, instr := range b.Instrs {
|
|
for _, op := range instr.Operands(ops[:0]) {
|
|
if op == nil || *op == nil {
|
|
continue
|
|
}
|
|
if callee, ok := (*op).(*ssa.Function); ok {
|
|
walk(callee, isInInstance)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for _, member := range ssaPkg.Members {
|
|
switch m := member.(type) {
|
|
case *ssa.Function:
|
|
walk(m, false)
|
|
case *ssa.Type:
|
|
mset := c.program.MethodSets.MethodSet(m.Type())
|
|
for method := range mset.Methods() {
|
|
walk(c.program.MethodValue(method), false)
|
|
}
|
|
pmset := c.program.MethodSets.MethodSet(types.NewPointer(m.Type()))
|
|
for method := range pmset.Methods() {
|
|
walk(c.program.MethodValue(method), false)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Registration is first-writer-wins (a synthetic TypeName may be
|
|
// reachable from several instances), so visit instances in a
|
|
// deterministic order. Pos() is a defensive tiebreaker.
|
|
sort.Slice(instances, func(i, j int) bool {
|
|
ri, rj := instances[i].RelString(nil), instances[j].RelString(nil)
|
|
if ri != rj {
|
|
return ri < rj
|
|
}
|
|
return instances[i].Pos() < instances[j].Pos()
|
|
})
|
|
for _, fn := range instances {
|
|
c.registerSyntheticLocalTypes(fn)
|
|
}
|
|
}
|
|
|
|
// registerSyntheticLocalTypes walks every type reachable from fn's
|
|
// body and records each synthetic *types.Named (TypeName.Parent() ==
|
|
// nil) in c.localTypeNames. Each is named with the canonical function
|
|
// name plus a per-function counter assigned in source order.
|
|
//
|
|
// First-writer-wins: a *types.Named already present in
|
|
// c.localTypeNames is left alone, so a synthetic type reachable from
|
|
// several instances keeps the name assigned by the first (in
|
|
// scanLocalTypes' deterministic order).
|
|
func (c *compilerContext) registerSyntheticLocalTypes(fn *ssa.Function) {
|
|
var found []*types.Named
|
|
seen := map[types.Type]struct{}{}
|
|
var visit func(t types.Type)
|
|
visit = func(t types.Type) {
|
|
if t == nil {
|
|
return
|
|
}
|
|
if _, ok := seen[t]; ok {
|
|
return
|
|
}
|
|
seen[t] = struct{}{}
|
|
switch t := t.(type) {
|
|
case *types.Alias:
|
|
visit(types.Unalias(t))
|
|
case *types.Named:
|
|
tn := t.Obj()
|
|
if tn.Pkg() != nil && tn.Parent() == nil {
|
|
if c.localTypeNames.At(t) == nil {
|
|
// Reserve the slot so later calls within this
|
|
// scanLocalTypes invocation skip it; the final
|
|
// name is filled in after sorting, before any
|
|
// getTypeCodeName lookups happen.
|
|
c.localTypeNames.Set(t, "")
|
|
found = append(found, t)
|
|
}
|
|
}
|
|
targs := t.TypeArgs()
|
|
for t := range targs.Types() {
|
|
visit(t)
|
|
}
|
|
visit(t.Underlying())
|
|
case *types.Pointer:
|
|
visit(t.Elem())
|
|
case *types.Slice:
|
|
visit(t.Elem())
|
|
case *types.Array:
|
|
visit(t.Elem())
|
|
case *types.Chan:
|
|
visit(t.Elem())
|
|
case *types.Map:
|
|
visit(t.Key())
|
|
visit(t.Elem())
|
|
case *types.Struct:
|
|
for field := range t.Fields() {
|
|
visit(field.Type())
|
|
}
|
|
case *types.Signature:
|
|
if p := t.Params(); p != nil {
|
|
for v := range p.Variables() {
|
|
visit(v.Type())
|
|
}
|
|
}
|
|
if r := t.Results(); r != nil {
|
|
for v := range r.Variables() {
|
|
visit(v.Type())
|
|
}
|
|
}
|
|
case *types.Tuple:
|
|
for v := range t.Variables() {
|
|
visit(v.Type())
|
|
}
|
|
case *types.Interface:
|
|
// A synthetic local type can be reachable only through a
|
|
// local interface's method signature, so descend into
|
|
// them. getTypeCodeName encodes those signatures into
|
|
// the interface's identifier, and the seen map breaks
|
|
// cycles formed by methods that mention the interface
|
|
// itself.
|
|
for method := range t.Methods() {
|
|
visit(method.Type())
|
|
}
|
|
}
|
|
}
|
|
for _, p := range fn.Params {
|
|
visit(p.Type())
|
|
}
|
|
for _, fv := range fn.FreeVars {
|
|
visit(fv.Type())
|
|
}
|
|
for _, l := range fn.Locals {
|
|
visit(l.Type())
|
|
}
|
|
var ops [10]*ssa.Value
|
|
for _, b := range fn.Blocks {
|
|
for _, instr := range b.Instrs {
|
|
if v, ok := instr.(ssa.Value); ok {
|
|
visit(v.Type())
|
|
}
|
|
for _, op := range instr.Operands(ops[:0]) {
|
|
if op != nil && *op != nil {
|
|
visit((*op).Type())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if len(found) == 0 {
|
|
return
|
|
}
|
|
// Sort by raw token.Pos: this gives a total order on declarations
|
|
// that is stable across builds and unaffected by //line directives
|
|
// (which only adjust the human-facing position from Fset.Position).
|
|
sort.Slice(found, func(i, j int) bool {
|
|
return found[i].Obj().Pos() < found[j].Obj().Pos()
|
|
})
|
|
enclosing := c.canonicalFunctionName(fn)
|
|
for i, named := range found {
|
|
c.localTypeNames.Set(named, fmt.Sprintf("%s.%s$%d", enclosing, named.Obj().Name(), i))
|
|
}
|
|
}
|
|
|
|
// getTypeMethodSet returns a reference (GEP) to a global method set. This
|
|
// method set should be unreferenced after the interface lowering pass.
|
|
func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
|
|
typeName, _ := c.getTypeCodeName(typ)
|
|
globalName := typeName + "$methodset"
|
|
global := c.mod.NamedGlobal(globalName)
|
|
if global.IsNil() {
|
|
ms := c.program.MethodSets.MethodSet(typ)
|
|
|
|
// Create method set.
|
|
var signatures, wrappers []llvm.Value
|
|
for method := range ms.Methods() {
|
|
signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
|
|
signatures = append(signatures, signatureGlobal)
|
|
fn := c.program.MethodValue(method)
|
|
llvmFnType, llvmFn := c.getFunction(fn)
|
|
if llvmFn.IsNil() {
|
|
// compiler error, so panic
|
|
panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
|
|
}
|
|
wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
|
|
wrappers = append(wrappers, wrapper)
|
|
}
|
|
|
|
// Construct global value.
|
|
globalValue := c.ctx.ConstStruct([]llvm.Value{
|
|
llvm.ConstInt(c.uintptrType, uint64(ms.Len()), false),
|
|
llvm.ConstArray(c.dataPtrType, signatures),
|
|
c.ctx.ConstStruct(wrappers, false),
|
|
}, false)
|
|
global = llvm.AddGlobal(c.mod, globalValue.Type(), globalName)
|
|
global.SetInitializer(globalValue)
|
|
global.SetGlobalConstant(true)
|
|
global.SetUnnamedAddr(true)
|
|
global.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
}
|
|
return global
|
|
}
|
|
|
|
// getMethodSignatureName returns a unique name (that can be used as the name of
|
|
// a global) for the given method.
|
|
func (c *compilerContext) getMethodSignatureName(method *types.Func) string {
|
|
name := method.Name()
|
|
var prefix string
|
|
if token.IsExported(method.Name()) {
|
|
prefix = "reflect/methods."
|
|
} else {
|
|
prefix = method.Type().(*types.Signature).Recv().Pkg().Path() + ".$methods."
|
|
}
|
|
signature, _ := c.getTypeCodeName(method.Type())
|
|
return prefix + name + ":" + signature
|
|
}
|
|
|
|
// getMethodSignature returns a global variable which is a reference to an
|
|
// external *i8 indicating the indicating the signature of this method. It is
|
|
// used during the interface lowering pass.
|
|
func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
|
|
globalName := c.getMethodSignatureName(method)
|
|
signatureGlobal := c.mod.NamedGlobal(globalName)
|
|
if signatureGlobal.IsNil() {
|
|
// TODO: put something useful in these globals, such as the method
|
|
// signature. Useful to one day implement reflect.Value.Method(n).
|
|
signatureGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
|
|
signatureGlobal.SetInitializer(llvm.ConstInt(c.ctx.Int8Type(), 0, false))
|
|
signatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
signatureGlobal.SetGlobalConstant(true)
|
|
signatureGlobal.SetAlignment(1)
|
|
}
|
|
return signatureGlobal
|
|
}
|
|
|
|
// createTypeAssert will emit the code for a typeassert, used in if statements
|
|
// and in type switches (Go SSA does not have type switches, only if/else
|
|
// chains). Note that even though the Go SSA does not contain type switches,
|
|
// LLVM will recognize the pattern and make it a real switch in many cases.
|
|
//
|
|
// Type asserts on concrete types are trivial: just compare type numbers. Type
|
|
// asserts on interfaces are more difficult, see the comments in the function.
|
|
func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
|
|
itf := b.getValue(expr.X, getPos(expr))
|
|
assertedType := b.getLLVMType(expr.AssertedType)
|
|
|
|
actualTypeNum := b.CreateExtractValue(itf, 0, "interface.type")
|
|
commaOk := llvm.Value{}
|
|
|
|
if intf, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
|
|
if intf.Empty() {
|
|
// intf is the empty interface => no methods
|
|
// This type assertion always succeeds, so we can just set commaOk to true.
|
|
commaOk = llvm.ConstInt(b.ctx.Int1Type(), 1, true)
|
|
} else {
|
|
// Type assert on an interface type with methods.
|
|
// Create a call to a declared-but-not-defined function that will
|
|
// be lowered by the interface lowering pass into a type-ID
|
|
// comparison chain.
|
|
commaOk = b.createInterfaceTypeAssert(intf, actualTypeNum)
|
|
}
|
|
} else {
|
|
name, _ := b.getTypeCodeName(expr.AssertedType)
|
|
globalName := "reflect/types.typeid:" + name
|
|
assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
|
|
if assertedTypeCodeGlobal.IsNil() {
|
|
// Create a new typecode global.
|
|
assertedTypeCodeGlobal = llvm.AddGlobal(b.mod, b.ctx.Int8Type(), globalName)
|
|
assertedTypeCodeGlobal.SetGlobalConstant(true)
|
|
}
|
|
// Type assert on concrete type.
|
|
// Call runtime.typeAssert, which will be lowered to a simple icmp or
|
|
// const false in the interface lowering pass.
|
|
commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
|
|
}
|
|
|
|
// Add 2 new basic blocks (that should get optimized away): one for the
|
|
// 'ok' case and one for all instructions following this type assert.
|
|
// This is necessary because we need to insert the casted value or the
|
|
// nil value based on whether the assert was successful. Casting before
|
|
// this check tells LLVM that it can use this value and may
|
|
// speculatively dereference pointers before the check. This can lead to
|
|
// a miscompilation resulting in a segfault at runtime.
|
|
// Additionally, this is even required by the Go spec: a failed
|
|
// typeassert should return a zero value, not an incorrectly casted
|
|
// value.
|
|
|
|
prevBlock := b.GetInsertBlock()
|
|
okBlock := b.insertBasicBlock("typeassert.ok")
|
|
|
|
if expr.CommaOk {
|
|
nextBlock := b.insertBasicBlock("typeassert.next")
|
|
b.currentBlockInfo.exit = nextBlock
|
|
if b.isIndirectAggregate(assertedType) {
|
|
resultType := b.getLLVMType(expr.Type())
|
|
result := b.createIndirectStorage(resultType, "typeassert.result")
|
|
b.zeroIndirectStorage(result, resultType)
|
|
b.CreateCondBr(commaOk, okBlock, nextBlock)
|
|
|
|
b.SetInsertPointAtEnd(okBlock)
|
|
valuePtr := b.extractValuePointerFromInterface(itf)
|
|
b.copyIndirectAggregate(b.CreateStructGEP(resultType, result, 0, ""), valuePtr, assertedType)
|
|
b.CreateBr(nextBlock)
|
|
|
|
b.SetInsertPointAtEnd(nextBlock)
|
|
b.CreateStore(commaOk, b.CreateStructGEP(resultType, result, 1, ""))
|
|
return result
|
|
}
|
|
b.CreateCondBr(commaOk, okBlock, nextBlock)
|
|
|
|
// Retrieve the value from the interface if the type assert was
|
|
// successful.
|
|
b.SetInsertPointAtEnd(okBlock)
|
|
var valueOk llvm.Value
|
|
if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
|
|
// Type assert on interface type. Easy: just return the same
|
|
// interface value.
|
|
valueOk = itf
|
|
} else {
|
|
// Type assert on concrete type. Extract the underlying type from
|
|
// the interface (but only after checking it matches).
|
|
valueOk = b.extractValueFromInterface(itf, assertedType)
|
|
}
|
|
b.CreateBr(nextBlock)
|
|
|
|
// Continue after the if statement.
|
|
b.SetInsertPointAtEnd(nextBlock)
|
|
phi := b.CreatePHI(assertedType, "typeassert.value")
|
|
phi.AddIncoming([]llvm.Value{llvm.ConstNull(assertedType), valueOk}, []llvm.BasicBlock{prevBlock, okBlock})
|
|
|
|
tuple := b.ctx.ConstStruct([]llvm.Value{llvm.Undef(assertedType), llvm.Undef(b.ctx.Int1Type())}, false) // create empty tuple
|
|
tuple = b.CreateInsertValue(tuple, phi, 0, "") // insert value
|
|
tuple = b.CreateInsertValue(tuple, commaOk, 1, "") // insert 'comma ok' boolean
|
|
return tuple
|
|
} else {
|
|
// Type assert without comma-ok. If it fails, panic.
|
|
faultBlock := b.getInterfaceAssertBlock()
|
|
b.currentBlockInfo.exit = okBlock
|
|
b.CreateCondBr(commaOk, okBlock, faultBlock)
|
|
|
|
// OK: extract the value from the interface.
|
|
b.SetInsertPointAtEnd(okBlock)
|
|
if _, ok := expr.AssertedType.Underlying().(*types.Interface); ok {
|
|
return itf
|
|
}
|
|
return b.extractValueFromInterface(itf, assertedType)
|
|
}
|
|
}
|
|
|
|
func (b *builder) getInterfaceAssertBlock() llvm.BasicBlock {
|
|
if !b.interfaceAssertBlock.IsNil() {
|
|
return b.interfaceAssertBlock
|
|
}
|
|
savedBlock := b.GetInsertBlock()
|
|
block := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.throw")
|
|
b.interfaceAssertBlock = block
|
|
b.SetInsertPointAtEnd(block)
|
|
if b.hasDeferFrame() {
|
|
b.createFaultCheckpoint()
|
|
}
|
|
b.createRuntimeCall("interfaceTypeAssert", []llvm.Value{llvm.ConstInt(b.ctx.Int1Type(), 0, false)}, "")
|
|
b.CreateUnreachable()
|
|
b.SetInsertPointAtEnd(savedBlock)
|
|
return block
|
|
}
|
|
|
|
// getMethodsString returns a string to be used in the "tinygo-methods" string
|
|
// attribute for interface functions.
|
|
func (c *compilerContext) getMethodsString(itf *types.Interface) string {
|
|
methods := make([]string, itf.NumMethods())
|
|
for i := range methods {
|
|
methods[i] = c.getMethodSignatureName(itf.Method(i))
|
|
}
|
|
return strings.Join(methods, "; ")
|
|
}
|
|
|
|
// getMethodSetValue creates the method set struct value for a list of methods.
|
|
// The struct contains a length and a sorted array of method signature pointers.
|
|
func (c *compilerContext) getMethodSetValue(methods []*types.Func) llvm.Value {
|
|
// Create a sorted list of method signature global names.
|
|
type methodRef struct {
|
|
name string
|
|
value llvm.Value
|
|
}
|
|
var refs []methodRef
|
|
for _, method := range methods {
|
|
name := method.Name()
|
|
if !token.IsExported(name) {
|
|
name = method.Pkg().Path() + "." + name
|
|
}
|
|
s, _ := c.getTypeCodeName(method.Type())
|
|
globalName := "reflect/types.signature:" + name + ":" + s
|
|
value := c.mod.NamedGlobal(globalName)
|
|
if value.IsNil() {
|
|
value = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
|
|
value.SetInitializer(llvm.ConstNull(c.ctx.Int8Type()))
|
|
value.SetGlobalConstant(true)
|
|
value.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
value.SetAlignment(1)
|
|
if c.Debug {
|
|
file := c.getDIFile("<Go type>")
|
|
diglobal := c.dibuilder.CreateGlobalVariableExpression(file, llvm.DIGlobalVariableExpression{
|
|
Name: globalName,
|
|
File: file,
|
|
Line: 1,
|
|
Type: c.getDIType(types.Typ[types.Uint8]),
|
|
LocalToUnit: false,
|
|
Expr: c.dibuilder.CreateExpression(nil),
|
|
AlignInBits: 8,
|
|
})
|
|
value.AddMetadata(0, diglobal)
|
|
}
|
|
}
|
|
refs = append(refs, methodRef{globalName, value})
|
|
}
|
|
sort.Slice(refs, func(i, j int) bool {
|
|
return refs[i].name < refs[j].name
|
|
})
|
|
|
|
var values []llvm.Value
|
|
for _, ref := range refs {
|
|
values = append(values, ref.value)
|
|
}
|
|
|
|
return c.ctx.ConstStruct([]llvm.Value{
|
|
llvm.ConstInt(c.uintptrType, uint64(len(values)), false),
|
|
llvm.ConstArray(c.dataPtrType, values),
|
|
}, false)
|
|
}
|
|
|
|
// getInvokeFunction returns the thunk to call the given interface method. The
|
|
// thunk is declared, not defined: it will be defined by the interface lowering
|
|
// pass.
|
|
func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
|
|
fnName := c.getInvokeFunctionName(instr)
|
|
llvmFn := c.mod.NamedFunction(fnName)
|
|
if llvmFn.IsNil() {
|
|
sig := instr.Method.Type().(*types.Signature)
|
|
var paramTuple []*types.Var
|
|
for v := range sig.Params().Variables() {
|
|
paramTuple = append(paramTuple, v)
|
|
}
|
|
paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.UnsafePointer]))
|
|
llvmFnType := c.getLLVMFunctionType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false))
|
|
llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
|
|
c.addStandardDeclaredAttributes(llvmFn)
|
|
llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-invoke", c.getMethodSignatureName(instr.Method)))
|
|
if _, indirect := c.hasIndirectResult(sig); indirect {
|
|
llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-indirect-result", "true"))
|
|
}
|
|
methods := c.getMethodsString(instr.Value.Type().Underlying().(*types.Interface))
|
|
llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
|
|
}
|
|
return llvmFn
|
|
}
|
|
|
|
func (c *compilerContext) getInvokeFunctionName(instr *ssa.CallCommon) string {
|
|
s, _ := c.getTypeCodeName(instr.Value.Type().Underlying())
|
|
return s + "." + instr.Method.Name() + "$invoke"
|
|
}
|
|
|
|
// createInterfaceTypeAssert creates a call to a declared-but-not-defined
|
|
// $typeassert function for the given interface. This function will be defined
|
|
// by the interface lowering pass as a type-ID comparison chain, avoiding the
|
|
// need for runtime.typeImplementsMethodSet at compile time.
|
|
func (b *builder) createInterfaceTypeAssert(intf *types.Interface, actualType llvm.Value) llvm.Value {
|
|
s, _ := b.getTypeCodeName(intf)
|
|
fnName := s + ".$typeassert"
|
|
llvmFn := b.mod.NamedFunction(fnName)
|
|
if llvmFn.IsNil() {
|
|
llvmFnType := llvm.FunctionType(b.ctx.Int1Type(), []llvm.Type{b.dataPtrType}, false)
|
|
llvmFn = llvm.AddFunction(b.mod, fnName, llvmFnType)
|
|
b.addStandardDeclaredAttributes(llvmFn)
|
|
methods := b.getMethodsString(intf)
|
|
llvmFn.AddFunctionAttr(b.ctx.CreateStringAttribute("tinygo-methods", methods))
|
|
}
|
|
return b.CreateCall(llvmFn.GlobalValueType(), llvmFn, []llvm.Value{actualType}, "")
|
|
}
|
|
|
|
// getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
|
|
// invoked from an interface. The wrapper takes in a pointer to the underlying
|
|
// value, dereferences or unpacks it if necessary, and calls the real method.
|
|
// If the method to wrap has a pointer receiver, no wrapping is necessary and
|
|
// the function is returned directly.
|
|
func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFnType llvm.Type, llvmFn llvm.Value) llvm.Value {
|
|
wrapperName := llvmFn.Name() + "$invoke"
|
|
wrapper := c.mod.NamedFunction(wrapperName)
|
|
if !wrapper.IsNil() {
|
|
// Wrapper already created. Return it directly.
|
|
return wrapper
|
|
}
|
|
|
|
// Get the expanded receiver type.
|
|
receiverType := c.getLLVMType(fn.Signature.Recv().Type())
|
|
var expandedReceiverType []llvm.Type
|
|
receiverIndirect := c.isIndirectAggregate(receiverType)
|
|
for _, info := range c.expandFormalParamType(receiverType, "", nil) {
|
|
expandedReceiverType = append(expandedReceiverType, info.llvmType)
|
|
}
|
|
|
|
// Does this method even need any wrapping?
|
|
if len(expandedReceiverType) == 1 && receiverType.TypeKind() == llvm.PointerTypeKind {
|
|
// Nothing to wrap.
|
|
// Casting a function signature to a different signature and calling it
|
|
// with a receiver pointer bitcasted to *i8 (as done in calls on an
|
|
// interface) is hopefully a safe (defined) operation.
|
|
return llvmFn
|
|
}
|
|
|
|
// create wrapper function
|
|
resultOffset := 0
|
|
if _, indirect := c.hasIndirectResult(fn.Signature); indirect {
|
|
resultOffset = 1
|
|
}
|
|
paramTypes := append([]llvm.Type{}, llvmFnType.ParamTypes()[:resultOffset]...)
|
|
paramTypes = append(paramTypes, c.dataPtrType)
|
|
paramTypes = append(paramTypes, llvmFnType.ParamTypes()[resultOffset+len(expandedReceiverType):]...)
|
|
wrapFnType := llvm.FunctionType(llvmFnType.ReturnType(), paramTypes, false)
|
|
wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
|
|
c.addStandardAttributes(wrapper)
|
|
|
|
wrapper.SetLinkage(llvm.LinkOnceODRLinkage)
|
|
wrapper.SetUnnamedAddr(true)
|
|
|
|
// Create a new builder just to create this wrapper.
|
|
b := builder{
|
|
compilerContext: c,
|
|
Builder: c.ctx.NewBuilder(),
|
|
}
|
|
defer b.Builder.Dispose()
|
|
|
|
// add debug info if needed
|
|
if c.Debug {
|
|
pos := c.program.Fset.Position(fn.Pos())
|
|
difunc := c.attachDebugInfoRaw(fn, wrapper, "$invoke", pos.Filename, pos.Line)
|
|
b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
|
|
}
|
|
|
|
// set up IR builder
|
|
block := b.ctx.AddBasicBlock(wrapper, "entry")
|
|
b.SetInsertPointAtEnd(block)
|
|
|
|
params := append([]llvm.Value{}, wrapper.Params()[:resultOffset]...)
|
|
receiverParam := wrapper.Param(resultOffset)
|
|
if receiverIndirect {
|
|
params = append(params, receiverParam)
|
|
} else {
|
|
receiverValue := b.emitPointerUnpack(receiverParam, []llvm.Type{receiverType})[0]
|
|
params = append(params, b.expandFormalParam(receiverValue)...)
|
|
}
|
|
params = append(params, wrapper.Params()[resultOffset+1:]...)
|
|
if llvmFnType.ReturnType().TypeKind() == llvm.VoidTypeKind {
|
|
b.CreateCall(llvmFnType, llvmFn, params, "")
|
|
b.CreateRetVoid()
|
|
} else {
|
|
ret := b.CreateCall(llvmFnType, llvmFn, params, "ret")
|
|
b.CreateRet(ret)
|
|
}
|
|
|
|
return wrapper
|
|
}
|