func (tm *TypeMap) nameRuntimeType(n *types.Named) (global, ptr llvm.Value) {
name := typeString(n)
path := "runtime"
if pkg := n.Obj().Pkg(); pkg != nil {
path = pkg.Path()
}
if path != tm.pkgpath {
// We're not compiling the package from whence the type came,
// so we'll just create a pointer to it here.
global := llvm.AddGlobal(tm.module, tm.runtime.rtype.llvm, typeSymbol(name))
global.SetInitializer(llvm.ConstNull(tm.runtime.rtype.llvm))
global.SetLinkage(llvm.CommonLinkage)
return global, global
}
// If the underlying type is Basic, then we always create
// a new global. Otherwise, we clone the value returned
// from toRuntime in case it is cached and reused.
underlying := n.Underlying()
if basic, ok := underlying.(*types.Basic); ok {
global, ptr = tm.basicRuntimeType(basic, true)
global.SetName(typeSymbol(name))
} else {
global, ptr = tm.toRuntime(underlying)
clone := llvm.AddGlobal(tm.module, global.Type().ElementType(), typeSymbol(name))
clone.SetInitializer(global.Initializer())
global = clone
ptr = llvm.ConstBitCast(global, llvm.PointerType(tm.runtime.rtype.llvm, 0))
}
global.SetLinkage(llvm.ExternalLinkage)
// Locate the rtype.
underlyingRuntimeType := global.Initializer()
rtype := underlyingRuntimeType
if rtype.Type() != tm.runtime.rtype.llvm {
rtype = llvm.ConstExtractValue(rtype, []uint32{0})
}
// Insert the uncommon type.
uncommonTypeInit := tm.uncommonType(n, nil)
uncommonType := llvm.AddGlobal(tm.module, uncommonTypeInit.Type(), "")
uncommonType.SetInitializer(uncommonTypeInit)
rtype = llvm.ConstInsertValue(rtype, uncommonType, []uint32{9})
// Replace the rtype's string representation with the one from
// uncommonType. XXX should we have the package name prepended? Probably.
namePtr := llvm.ConstExtractValue(uncommonTypeInit, []uint32{0})
rtype = llvm.ConstInsertValue(rtype, namePtr, []uint32{8})
// Update the global's initialiser. Note that we take a copy
// of the underlying type; we're not updating a shared type.
if underlyingRuntimeType.Type() != tm.runtime.rtype.llvm {
underlyingRuntimeType = llvm.ConstInsertValue(underlyingRuntimeType, rtype, []uint32{0})
} else {
underlyingRuntimeType = rtype
}
global.SetInitializer(underlyingRuntimeType)
return global, ptr
}
// indirectFunction creates an indirect function from a
// given function and arguments, suitable for use with
// "defer" and "go".
func (c *compiler) indirectFunction(fn *LLVMValue, args []*LLVMValue) *LLVMValue {
nilarytyp := types.NewSignature(nil, nil, nil, nil, false)
if len(args) == 0 {
val := fn.LLVMValue()
ptr := c.builder.CreateExtractValue(val, 0, "")
ctx := c.builder.CreateExtractValue(val, 1, "")
fnval := llvm.Undef(c.types.ToLLVM(nilarytyp))
ptr = c.builder.CreateBitCast(ptr, fnval.Type().StructElementTypes()[0], "")
ctx = c.builder.CreateBitCast(ctx, fnval.Type().StructElementTypes()[1], "")
fnval = c.builder.CreateInsertValue(fnval, ptr, 0, "")
fnval = c.builder.CreateInsertValue(fnval, ctx, 1, "")
return c.NewValue(fnval, nilarytyp)
}
// Check if function pointer or context pointer is global/null.
fnval := fn.LLVMValue()
fnptr := fnval
var nctx int
var fnctx llvm.Value
var fnctxindex uint64
var globalfn bool
if fnptr.Type().TypeKind() == llvm.StructTypeKind {
fnptr = c.builder.CreateExtractValue(fnval, 0, "")
fnctx = c.builder.CreateExtractValue(fnval, 1, "")
globalfn = !fnptr.IsAFunction().IsNil()
if !globalfn {
nctx++
}
if !fnctx.IsNull() {
fnctxindex = uint64(nctx)
nctx++
}
} else {
// We've got a raw global function pointer. Convert to <ptr,ctx>.
fnval = llvm.ConstNull(c.types.ToLLVM(fn.Type()))
fnval = llvm.ConstInsertValue(fnval, fnptr, []uint32{0})
fn = c.NewValue(fnval, fn.Type())
fnctx = llvm.ConstExtractValue(fnval, []uint32{1})
globalfn = true
}
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
llvmargs := make([]llvm.Value, len(args)+nctx)
llvmargtypes := make([]llvm.Type, len(args)+nctx)
for i, arg := range args {
llvmargs[i+nctx] = arg.LLVMValue()
llvmargtypes[i+nctx] = llvmargs[i+nctx].Type()
}
if !globalfn {
llvmargtypes[0] = fnptr.Type()
llvmargs[0] = fnptr
}
if !fnctx.IsNull() {
llvmargtypes[fnctxindex] = fnctx.Type()
llvmargs[fnctxindex] = fnctx
}
// TODO(axw) investigate an option for go statements
// to allocate argument structure on the stack in the
// initiator, and block until the spawned goroutine
// has loaded the arguments from it.
structtyp := llvm.StructType(llvmargtypes, false)
argstruct := c.createTypeMalloc(structtyp)
for i, llvmarg := range llvmargs {
argptr := c.builder.CreateGEP(argstruct, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), uint64(i), false)}, "")
c.builder.CreateStore(llvmarg, argptr)
}
// Create a function that will take a pointer to a structure of the type
// defined above, or no parameters if there are none to pass.
fntype := llvm.FunctionType(llvm.VoidType(), []llvm.Type{argstruct.Type()}, false)
indirectfn := llvm.AddFunction(c.module.Module, "", fntype)
i8argstruct := c.builder.CreateBitCast(argstruct, i8ptr, "")
currblock := c.builder.GetInsertBlock()
c.builder.SetInsertPointAtEnd(llvm.AddBasicBlock(indirectfn, "entry"))
argstruct = indirectfn.Param(0)
newargs := make([]*LLVMValue, len(args))
for i := range llvmargs[nctx:] {
argptr := c.builder.CreateGEP(argstruct, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), uint64(i+nctx), false)}, "")
newargs[i] = c.NewValue(c.builder.CreateLoad(argptr, ""), args[i].Type())
}
// Unless we've got a global function, extract the
// function pointer from the context.
if !globalfn {
fnval = llvm.Undef(fnval.Type())
fnptrptr := c.builder.CreateGEP(argstruct, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), 0, false)}, "")
fnptr = c.builder.CreateLoad(fnptrptr, "")
fnval = c.builder.CreateInsertValue(fnval, fnptr, 0, "")
}
if !fnctx.IsNull() {
fnctxptr := c.builder.CreateGEP(argstruct, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), fnctxindex, false)}, "")
fnctx = c.builder.CreateLoad(fnctxptr, "")
fnval = c.builder.CreateInsertValue(fnval, fnctx, 1, "")
fn = c.NewValue(fnval, fn.Type())
}
c.createCall(fn, newargs)
// Indirect function calls' return values are always ignored.
c.builder.CreateRetVoid()
c.builder.SetInsertPointAtEnd(currblock)
fnval = llvm.Undef(c.types.ToLLVM(nilarytyp))
indirectfn = c.builder.CreateBitCast(indirectfn, fnval.Type().StructElementTypes()[0], "")
fnval = c.builder.CreateInsertValue(fnval, indirectfn, 0, "")
fnval = c.builder.CreateInsertValue(fnval, i8argstruct, 1, "")
fn = c.NewValue(fnval, nilarytyp)
return fn
}
func (tm *TypeMap) pointerRuntimeType(p *types.Pointer) (global, ptr llvm.Value) {
// Is the base type a named type from another package? If so, we'll
// create a reference to the externally defined symbol.
linkage := llvm.LinkOnceAnyLinkage
switch elem := p.Elem().(type) {
case *types.Basic:
if tm.pkgpath != "runtime" {
global := llvm.AddGlobal(tm.module, tm.runtime.rtype.llvm, typeSymbol(typeString(p)))
global.SetInitializer(llvm.ConstNull(tm.runtime.rtype.llvm))
global.SetLinkage(llvm.CommonLinkage)
return global, global
}
linkage = llvm.ExternalLinkage
case *types.Named:
path := "runtime"
if pkg := elem.Obj().Pkg(); pkg != nil {
path = pkg.Path()
}
if path != tm.pkgpath {
global := llvm.AddGlobal(tm.module, tm.runtime.rtype.llvm, typeSymbol(typeString(p)))
global.SetInitializer(llvm.ConstNull(tm.runtime.rtype.llvm))
global.SetLinkage(llvm.CommonLinkage)
return global, global
}
linkage = llvm.ExternalLinkage
}
rtype := tm.makeRtype(p, reflect.Ptr)
if n, ok := p.Elem().(*types.Named); ok {
uncommonTypeInit := tm.uncommonType(n, p)
uncommonType := llvm.AddGlobal(tm.module, uncommonTypeInit.Type(), "")
uncommonType.SetInitializer(uncommonTypeInit)
rtype = llvm.ConstInsertValue(rtype, uncommonType, []uint32{9})
}
ptrType := llvm.ConstNull(tm.runtime.ptrType.llvm)
var baseTypeGlobal llvm.Value
if p.Elem().Underlying() == p {
// Recursive pointer.
ptrType = llvm.ConstInsertValue(ptrType, rtype, []uint32{0})
global, ptr = tm.makeRuntimeTypeGlobal(ptrType, typeString(p))
baseTypeGlobal = global
// Update the global with its own pointer in the elem field.
ptrType = global.Initializer()
ptrType = llvm.ConstInsertValue(ptrType, ptr, []uint32{1})
global.SetInitializer(ptrType)
} else {
var baseTypePtr llvm.Value
baseTypeGlobal, baseTypePtr = tm.toRuntime(p.Elem())
ptrType = llvm.ConstInsertValue(ptrType, rtype, []uint32{0})
ptrType = llvm.ConstInsertValue(ptrType, baseTypePtr, []uint32{1})
global, ptr = tm.makeRuntimeTypeGlobal(ptrType, typeString(p))
}
global.SetLinkage(linkage)
// Set ptrToThis in the base type's rtype.
baseType := baseTypeGlobal.Initializer()
if !baseType.IsNull() {
if baseType.Type() == tm.runtime.rtype.llvm {
baseType = llvm.ConstInsertValue(baseType, ptr, []uint32{10})
} else {
rtype := llvm.ConstExtractValue(baseType, []uint32{0})
rtype = llvm.ConstInsertValue(rtype, ptr, []uint32{10})
baseType = llvm.ConstInsertValue(baseType, rtype, []uint32{0})
}
baseTypeGlobal.SetInitializer(baseType)
}
return global, ptr
}