func (tm *llvmTypeMap) basicLLVMType(b *types.Basic) llvm.Type {
switch b.Kind() {
case types.Bool:
return llvm.Int1Type()
case types.Int8, types.Uint8:
return llvm.Int8Type()
case types.Int16, types.Uint16:
return llvm.Int16Type()
case types.Int32, types.Uint32:
return llvm.Int32Type()
case types.Uint, types.Int:
return tm.inttype
case types.Int64, types.Uint64:
return llvm.Int64Type()
case types.Float32:
return llvm.FloatType()
case types.Float64:
return llvm.DoubleType()
case types.UnsafePointer, types.Uintptr:
return tm.target.IntPtrType()
case types.Complex64:
f32 := llvm.FloatType()
elements := []llvm.Type{f32, f32}
return llvm.StructType(elements, false)
case types.Complex128:
f64 := llvm.DoubleType()
elements := []llvm.Type{f64, f64}
return llvm.StructType(elements, false)
case types.String:
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
elements := []llvm.Type{i8ptr, tm.inttype}
return llvm.StructType(elements, false)
}
panic(fmt.Sprint("unhandled kind: ", b.Kind))
}
func (c *compiler) makeInterface(v *LLVMValue, iface types.Type) *LLVMValue {
llv := v.LLVMValue()
lltyp := llv.Type()
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
if lltyp.TypeKind() == llvm.PointerTypeKind {
llv = c.builder.CreateBitCast(llv, i8ptr, "")
} else {
// If the value fits exactly in a pointer, then we can just
// bitcast it. Otherwise we need to malloc.
if c.target.TypeStoreSize(lltyp) <= uint64(c.target.PointerSize()) {
bits := c.target.TypeSizeInBits(lltyp)
if bits > 0 {
llv = coerce(c.builder, llv, llvm.IntType(int(bits)))
llv = c.builder.CreateIntToPtr(llv, i8ptr, "")
} else {
llv = llvm.ConstNull(i8ptr)
}
} else {
ptr := c.createTypeMalloc(lltyp)
c.builder.CreateStore(llv, ptr)
llv = c.builder.CreateBitCast(ptr, i8ptr, "")
}
}
value := llvm.Undef(c.types.ToLLVM(iface))
rtype := c.types.ToRuntime(v.Type())
rtype = c.builder.CreateBitCast(rtype, llvm.PointerType(llvm.Int8Type(), 0), "")
value = c.builder.CreateInsertValue(value, rtype, 0, "")
value = c.builder.CreateInsertValue(value, llv, 1, "")
if iface.Underlying().(*types.Interface).NumMethods() > 0 {
result := c.NewValue(value, types.NewInterface(nil, nil))
result, _ = result.convertE2I(iface)
return result
}
return c.NewValue(value, iface)
}
func getPrintf(module llvm.Module) llvm.Value {
printf := module.NamedFunction("printf")
if printf.IsNil() {
charPtr := llvm.PointerType(llvm.Int8Type(), 0)
ftyp := llvm.FunctionType(llvm.Int32Type(), []llvm.Type{charPtr}, true)
printf = llvm.AddFunction(module, "printf", ftyp)
printf.SetFunctionCallConv(llvm.CCallConv)
}
return printf
}
func getFflush(module llvm.Module) llvm.Value {
fflush := module.NamedFunction("fflush")
if fflush.IsNil() {
voidPtr := llvm.PointerType(llvm.Int8Type(), 0)
ftyp := llvm.FunctionType(llvm.Int32Type(), []llvm.Type{voidPtr}, false)
fflush = llvm.AddFunction(module, "fflush", ftyp)
fflush.SetFunctionCallConv(llvm.CCallConv)
}
return fflush
}
func (c *compiler) createMainFunction() error {
// In a PNaCl program (plugin), there should not be a "main.main";
// instead, we expect a "main.CreateModule" function.
// See pkg/nacl/ppapi/ppapi.go for more details.
mainMain := c.module.NamedFunction("main.main")
/*
if c.pnacl {
// PNaCl's libppapi_stub.a implements "main", which simply
// calls through to PpapiPluginMain. We define our own "main"
// so that we can capture argc/argv.
if !mainMain.IsNil() {
return fmt.Errorf("Found main.main")
}
pluginMain := c.RuntimeFunction("PpapiPluginMain", "func() int32")
// Synthesise a main which has no return value. We could cast
// PpapiPluginMain, but this is potentially unsafe as its
// calling convention is unspecified.
ftyp := llvm.FunctionType(llvm.VoidType(), nil, false)
mainMain = llvm.AddFunction(c.module.Module, "main.main", ftyp)
entry := llvm.AddBasicBlock(mainMain, "entry")
c.builder.SetInsertPointAtEnd(entry)
c.builder.CreateCall(pluginMain, nil, "")
c.builder.CreateRetVoid()
} else */{
mainMain = c.module.NamedFunction("main.main")
}
if mainMain.IsNil() {
return fmt.Errorf("Could not find main.main")
}
// runtime.main is called by main, with argc, argv, argp,
// and a pointer to main.main, which must be a niladic
// function with no result.
runtimeMain := c.runtime.main.LLVMValue()
ptrptr := llvm.PointerType(llvm.PointerType(llvm.Int8Type(), 0), 0)
ftyp := llvm.FunctionType(llvm.Int32Type(), []llvm.Type{llvm.Int32Type(), ptrptr, ptrptr}, true)
main := llvm.AddFunction(c.module.Module, "main", ftyp)
c.builder.SetCurrentDebugLocation(c.debug.MDNode(nil))
entry := llvm.AddBasicBlock(main, "entry")
c.builder.SetInsertPointAtEnd(entry)
runtimeMainParamTypes := runtimeMain.Type().ElementType().ParamTypes()
args := []llvm.Value{
main.Param(0), // argc
main.Param(1), // argv
main.Param(2), // argp
c.builder.CreateBitCast(mainMain, runtimeMainParamTypes[3], ""),
}
result := c.builder.CreateCall(runtimeMain, args, "")
c.builder.CreateRet(result)
return nil
}
// globalStringPtr returns a *string with the specified value.
func (tm *TypeMap) globalStringPtr(value string) llvm.Value {
strval := llvm.ConstString(value, false)
strglobal := llvm.AddGlobal(tm.module, strval.Type(), "")
strglobal.SetInitializer(strval)
strglobal = llvm.ConstBitCast(strglobal, llvm.PointerType(llvm.Int8Type(), 0))
strlen := llvm.ConstInt(tm.inttype, uint64(len(value)), false)
str := llvm.ConstStruct([]llvm.Value{strglobal, strlen}, false)
g := llvm.AddGlobal(tm.module, str.Type(), "")
g.SetInitializer(str)
return g
}
func (c *compiler) memsetZero(ptr llvm.Value, size llvm.Value) {
memset := c.runtime.memset.LLVMValue()
switch n := size.Type().IntTypeWidth() - c.target.IntPtrType().IntTypeWidth(); {
case n < 0:
size = c.builder.CreateZExt(size, c.target.IntPtrType(), "")
case n > 0:
size = c.builder.CreateTrunc(size, c.target.IntPtrType(), "")
}
ptr = c.builder.CreatePtrToInt(ptr, c.target.IntPtrType(), "")
fill := llvm.ConstNull(llvm.Int8Type())
c.builder.CreateCall(memset, []llvm.Value{ptr, fill, size}, "")
}
func (tm *llvmTypeMap) funcLLVMType(f *types.Signature, name string) llvm.Type {
// If there's a receiver change the receiver to an
// additional (first) parameter, and take the value of
// the resulting signature instead.
if recv := f.Recv(); recv != nil {
params := f.Params()
paramvars := make([]*types.Var, int(params.Len()+1))
paramvars[0] = recv
for i := 0; i < int(params.Len()); i++ {
paramvars[i+1] = params.At(i)
}
params = types.NewTuple(paramvars...)
f := types.NewSignature(nil, nil, params, f.Results(), f.Variadic())
return tm.toLLVM(f, name)
}
if typ, ok := tm.types.At(f).(llvm.Type); ok {
return typ
}
typ := llvm.GlobalContext().StructCreateNamed(name)
tm.types.Set(f, typ)
params := f.Params()
param_types := make([]llvm.Type, params.Len())
for i := range param_types {
llvmtyp := tm.ToLLVM(params.At(i).Type())
param_types[i] = llvmtyp
}
var return_type llvm.Type
results := f.Results()
switch nresults := int(results.Len()); nresults {
case 0:
return_type = llvm.VoidType()
case 1:
return_type = tm.ToLLVM(results.At(0).Type())
default:
elements := make([]llvm.Type, nresults)
for i := range elements {
result := results.At(i)
elements[i] = tm.ToLLVM(result.Type())
}
return_type = llvm.StructType(elements, false)
}
fntyp := llvm.FunctionType(return_type, param_types, false)
fnptrtyp := llvm.PointerType(fntyp, 0)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
elements := []llvm.Type{fnptrtyp, i8ptr} // func, closure
typ.StructSetBody(elements, false)
return typ
}
func (tm *TypeMap) makeRtype(t types.Type, k reflect.Kind) llvm.Value {
// Not sure if there's an easier way to do this, but if you just
// use ConstStruct, you end up getting a different llvm.Type.
typ := llvm.ConstNull(tm.runtime.rtype.llvm)
elementTypes := tm.runtime.rtype.llvm.StructElementTypes()
// Size.
size := llvm.ConstInt(elementTypes[0], uint64(tm.Sizeof(t)), false)
typ = llvm.ConstInsertValue(typ, size, []uint32{0})
// TODO hash
// TODO padding
// Alignment.
align := llvm.ConstInt(llvm.Int8Type(), uint64(tm.Alignof(t)), false)
typ = llvm.ConstInsertValue(typ, align, []uint32{3}) // var
typ = llvm.ConstInsertValue(typ, align, []uint32{4}) // field
// Kind.
kind := llvm.ConstInt(llvm.Int8Type(), uint64(k), false)
typ = llvm.ConstInsertValue(typ, kind, []uint32{5})
// Algorithm table.
alg := tm.makeAlgorithmTable(t)
algptr := llvm.AddGlobal(tm.module, alg.Type(), "")
algptr.SetInitializer(alg)
algptr = llvm.ConstBitCast(algptr, elementTypes[6])
typ = llvm.ConstInsertValue(typ, algptr, []uint32{6})
// String representation.
stringrep := tm.globalStringPtr(t.String())
typ = llvm.ConstInsertValue(typ, stringrep, []uint32{8})
// TODO gc
return typ
}
func (tm *llvmTypeMap) interfaceLLVMType(i *types.Interface, name string) llvm.Type {
if typ, ok := tm.types.At(i).(llvm.Type); ok {
return typ
}
// interface{} is represented as {type, value},
// and non-empty interfaces are represented as {itab, value}.
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
rtypeType := i8ptr
valueType := i8ptr
if name == "" {
name = i.String()
}
typ := llvm.GlobalContext().StructCreateNamed(name)
typ.StructSetBody([]llvm.Type{rtypeType, valueType}, false)
return typ
}
func newAlgorithmMap(m llvm.Module, runtime *runtimeInterface, target llvm.TargetData) *algorithmMap {
am := &algorithmMap{
module: m,
runtime: runtime,
}
uintptrType := target.IntPtrType()
voidPtrType := llvm.PointerType(llvm.Int8Type(), 0)
boolType := llvm.Int1Type()
params := []llvm.Type{uintptrType, voidPtrType}
am.hashAlgFunctionType = llvm.FunctionType(uintptrType, params, false)
params = []llvm.Type{uintptrType, uintptrType, uintptrType}
am.equalAlgFunctionType = llvm.FunctionType(boolType, params, false)
params = []llvm.Type{uintptrType, voidPtrType}
am.printAlgFunctionType = llvm.FunctionType(llvm.VoidType(), params, false)
params = []llvm.Type{uintptrType, voidPtrType, voidPtrType}
am.copyAlgFunctionType = llvm.FunctionType(llvm.VoidType(), params, false)
return am
}
// makeClosure creates a closure from a function pointer and
// a set of bindings. The bindings are addresses of captured
// variables.
func (c *compiler) makeClosure(fn *LLVMValue, bindings []*LLVMValue) *LLVMValue {
types := make([]llvm.Type, len(bindings))
for i, binding := range bindings {
types[i] = c.types.ToLLVM(binding.Type())
}
block := c.createTypeMalloc(llvm.StructType(types, false))
for i, binding := range bindings {
addressPtr := c.builder.CreateStructGEP(block, i, "")
c.builder.CreateStore(binding.LLVMValue(), addressPtr)
}
block = c.builder.CreateBitCast(block, llvm.PointerType(llvm.Int8Type(), 0), "")
// fn is a raw function pointer; ToLLVM yields {*fn, *uint8}.
closure := llvm.Undef(c.types.ToLLVM(fn.Type()))
fnptr := c.builder.CreateBitCast(fn.LLVMValue(), closure.Type().StructElementTypes()[0], "")
closure = c.builder.CreateInsertValue(closure, fnptr, 0, "")
closure = c.builder.CreateInsertValue(closure, block, 1, "")
return c.NewValue(closure, fn.Type())
}
func (c *compiler) getBoolString(v llvm.Value) llvm.Value {
startBlock := c.builder.GetInsertBlock()
resultBlock := llvm.InsertBasicBlock(startBlock, "")
resultBlock.MoveAfter(startBlock)
falseBlock := llvm.InsertBasicBlock(resultBlock, "")
CharPtr := llvm.PointerType(llvm.Int8Type(), 0)
falseString := c.builder.CreateGlobalStringPtr("false", "")
falseString = c.builder.CreateBitCast(falseString, CharPtr, "")
trueString := c.builder.CreateGlobalStringPtr("true", "")
trueString = c.builder.CreateBitCast(trueString, CharPtr, "")
c.builder.CreateCondBr(v, resultBlock, falseBlock)
c.builder.SetInsertPointAtEnd(falseBlock)
c.builder.CreateBr(resultBlock)
c.builder.SetInsertPointAtEnd(resultBlock)
result := c.builder.CreatePHI(CharPtr, "")
result.AddIncoming([]llvm.Value{trueString, falseString},
[]llvm.BasicBlock{startBlock, falseBlock})
return result
}
func (tm *TypeMap) interfaceFuncWrapper(f llvm.Value) llvm.Value {
ftyp := f.Type().ElementType()
paramTypes := ftyp.ParamTypes()
recvType := paramTypes[0]
paramTypes[0] = llvm.PointerType(llvm.Int8Type(), 0)
newf := llvm.AddFunction(f.GlobalParent(), f.Name()+".ifn", llvm.FunctionType(
ftyp.ReturnType(),
paramTypes,
ftyp.IsFunctionVarArg(),
))
b := llvm.GlobalContext().NewBuilder()
defer b.Dispose()
entry := llvm.AddBasicBlock(newf, "entry")
b.SetInsertPointAtEnd(entry)
args := make([]llvm.Value, len(paramTypes))
for i := range paramTypes {
args[i] = newf.Param(i)
}
recvBits := int(tm.target.TypeSizeInBits(recvType))
if recvBits > 0 {
args[0] = b.CreatePtrToInt(args[0], tm.target.IntPtrType(), "")
if args[0].Type().IntTypeWidth() > recvBits {
args[0] = b.CreateTrunc(args[0], llvm.IntType(recvBits), "")
}
args[0] = coerce(b, args[0], recvType)
} else {
args[0] = llvm.ConstNull(recvType)
}
result := b.CreateCall(f, args, "")
if result.Type().TypeKind() == llvm.VoidTypeKind {
b.CreateRetVoid()
} else {
b.CreateRet(result)
}
return newf
}
func (u *unit) defineFunction(f *ssa.Function) {
// Nothing to do for functions without bodies.
if len(f.Blocks) == 0 {
return
}
// Only define functions from this package.
if f.Pkg == nil {
if r := f.Signature.Recv(); r != nil {
if r.Pkg() != nil && r.Pkg() != u.pkg.Object {
return
} else if named, ok := r.Type().(*types.Named); ok && named.Obj().Parent() == types.Universe {
// This condition is true iff f is error.Error.
if u.pkg.Object.Path() != "runtime" {
return
}
}
}
} else if f.Pkg != u.pkg {
return
}
fr := frame{
unit: u,
blocks: make([]llvm.BasicBlock, len(f.Blocks)),
env: make(map[ssa.Value]*LLVMValue),
}
fr.logf("Define function: %s", f.String())
llvmFunction := fr.resolveFunction(f).LLVMValue()
delete(u.undefinedFuncs, f)
// Push the function onto the debug context.
// TODO(axw) create a fake CU for synthetic functions
if u.GenerateDebug && f.Synthetic == "" {
u.debug.pushFunctionContext(llvmFunction, f.Signature, f.Pos())
defer u.debug.popFunctionContext()
u.debug.setLocation(u.builder, f.Pos())
}
// Functions that call recover must not be inlined, or we
// can't tell whether the recover call is valid at runtime.
if f.Recover != nil {
llvmFunction.AddFunctionAttr(llvm.NoInlineAttribute)
}
for i, block := range f.Blocks {
fr.blocks[i] = llvm.AddBasicBlock(llvmFunction, fmt.Sprintf(".%d.%s", i, block.Comment))
}
fr.builder.SetInsertPointAtEnd(fr.blocks[0])
var paramOffset int
if len(f.FreeVars) > 0 {
// Extract captures from the first implicit parameter.
arg0 := llvmFunction.Param(0)
for i, fv := range f.FreeVars {
addressPtr := fr.builder.CreateStructGEP(arg0, i, "")
address := fr.builder.CreateLoad(addressPtr, "")
fr.env[fv] = fr.NewValue(address, fv.Type())
}
paramOffset++
}
// Map parameter positions to indices. We use this
// when processing locals to map back to parameters
// when generating debug metadata.
paramPos := make(map[token.Pos]int)
for i, param := range f.Params {
paramPos[param.Pos()] = i + paramOffset
llparam := llvmFunction.Param(i + paramOffset)
fr.env[param] = fr.NewValue(llparam, param.Type())
}
// Allocate stack space for locals in the prologue block.
prologueBlock := llvm.InsertBasicBlock(fr.blocks[0], "prologue")
fr.builder.SetInsertPointAtEnd(prologueBlock)
for _, local := range f.Locals {
typ := fr.llvmtypes.ToLLVM(deref(local.Type()))
alloca := fr.builder.CreateAlloca(typ, local.Comment)
u.memsetZero(alloca, llvm.SizeOf(typ))
value := fr.NewValue(alloca, local.Type())
fr.env[local] = value
if fr.GenerateDebug {
paramIndex, ok := paramPos[local.Pos()]
if !ok {
paramIndex = -1
}
fr.debug.declare(fr.builder, local, alloca, paramIndex)
}
}
// Move any allocs relating to named results from the entry block
// to the prologue block, so they dominate the rundefers and recover
// blocks.
//
// TODO(axw) ask adonovan for a cleaner way of doing this, e.g.
// have ssa generate an entry block that defines Allocs and related
// stores, and then a separate block for function body instructions.
if f.Synthetic == "" {
if results := f.Signature.Results(); results != nil {
for i := 0; i < results.Len(); i++ {
result := results.At(i)
if result.Name() == "" {
break
}
for i, instr := range f.Blocks[0].Instrs {
if instr, ok := instr.(*ssa.Alloc); ok && instr.Heap && instr.Pos() == result.Pos() {
fr.instruction(instr)
instrs := f.Blocks[0].Instrs
instrs = append(instrs[:i], instrs[i+1:]...)
f.Blocks[0].Instrs = instrs
break
}
}
}
}
}
// If the function contains any defers, we must first call
// setjmp so we can call rundefers in response to a panic.
// We can short-circuit the check for defers with
// f.Recover != nil.
if f.Recover != nil || hasDefer(f) {
rdblock := llvm.AddBasicBlock(llvmFunction, "rundefers")
defers := fr.builder.CreateAlloca(fr.runtime.defers.llvm, "")
fr.builder.CreateCall(fr.runtime.initdefers.LLVMValue(), []llvm.Value{defers}, "")
jb := fr.builder.CreateStructGEP(defers, 0, "")
jb = fr.builder.CreateBitCast(jb, llvm.PointerType(llvm.Int8Type(), 0), "")
result := fr.builder.CreateCall(fr.runtime.setjmp.LLVMValue(), []llvm.Value{jb}, "")
result = fr.builder.CreateIsNotNull(result, "")
fr.builder.CreateCondBr(result, rdblock, fr.blocks[0])
// We'll only get here via a panic, which must either be
// recovered or continue panicking up the stack without
// returning from "rundefers". The recover block may be
// nil even if we can recover, in which case we just need
// to return the zero value for each result (if any).
var recoverBlock llvm.BasicBlock
if f.Recover != nil {
recoverBlock = fr.block(f.Recover)
} else {
recoverBlock = llvm.AddBasicBlock(llvmFunction, "recover")
fr.builder.SetInsertPointAtEnd(recoverBlock)
var nresults int
results := f.Signature.Results()
if results != nil {
nresults = results.Len()
}
switch nresults {
case 0:
fr.builder.CreateRetVoid()
case 1:
fr.builder.CreateRet(llvm.ConstNull(fr.llvmtypes.ToLLVM(results.At(0).Type())))
default:
values := make([]llvm.Value, nresults)
for i := range values {
values[i] = llvm.ConstNull(fr.llvmtypes.ToLLVM(results.At(i).Type()))
}
fr.builder.CreateAggregateRet(values)
}
}
fr.builder.SetInsertPointAtEnd(rdblock)
fr.builder.CreateCall(fr.runtime.rundefers.LLVMValue(), nil, "")
fr.builder.CreateBr(recoverBlock)
} else {
fr.builder.CreateBr(fr.blocks[0])
}
for i, block := range f.Blocks {
fr.translateBlock(block, fr.blocks[i])
}
}
func (c *compiler) chanSelect(states []selectState, blocking bool) *LLVMValue {
stackptr := c.stacksave()
defer c.stackrestore(stackptr)
n := uint64(len(states))
if !blocking {
// blocking means there's no default case
n++
}
lln := llvm.ConstInt(llvm.Int32Type(), n, false)
allocsize := c.builder.CreateCall(c.runtime.selectsize.LLVMValue(), []llvm.Value{lln}, "")
selectp := c.builder.CreateArrayAlloca(llvm.Int8Type(), allocsize, "selectp")
c.memsetZero(selectp, allocsize)
selectp = c.builder.CreatePtrToInt(selectp, c.target.IntPtrType(), "")
c.builder.CreateCall(c.runtime.selectinit.LLVMValue(), []llvm.Value{lln, selectp}, "")
// Allocate stack for the values to send/receive.
//
// TODO(axw) request optimisation in ssa to special-
// case receive cases with no assignment, so we know
// not to allocate stack space or do a copy.
resTypes := []types.Type{types.Typ[types.Int], types.Typ[types.Bool]}
for _, state := range states {
if state.Dir == types.RecvOnly {
chantyp := state.Chan.Type().Underlying().(*types.Chan)
resTypes = append(resTypes, chantyp.Elem())
}
}
resType := tupleType(resTypes...)
llResType := c.types.ToLLVM(resType)
tupleptr := c.builder.CreateAlloca(llResType, "")
c.memsetZero(tupleptr, llvm.SizeOf(llResType))
var recvindex int
ptrs := make([]llvm.Value, len(states))
for i, state := range states {
chantyp := state.Chan.Type().Underlying().(*types.Chan)
elemtyp := c.types.ToLLVM(chantyp.Elem())
if state.Dir == types.SendOnly {
ptrs[i] = c.builder.CreateAlloca(elemtyp, "")
c.builder.CreateStore(state.Send.LLVMValue(), ptrs[i])
} else {
ptrs[i] = c.builder.CreateStructGEP(tupleptr, recvindex+2, "")
recvindex++
}
ptrs[i] = c.builder.CreatePtrToInt(ptrs[i], c.target.IntPtrType(), "")
}
// Create select{send,recv} calls.
selectsend := c.runtime.selectsend.LLVMValue()
selectrecv := c.runtime.selectrecv.LLVMValue()
var received llvm.Value
if recvindex > 0 {
received = c.builder.CreateStructGEP(tupleptr, 1, "")
}
if !blocking {
c.builder.CreateCall(c.runtime.selectdefault.LLVMValue(), []llvm.Value{selectp}, "")
}
for i, state := range states {
ch := state.Chan.LLVMValue()
if state.Dir == types.SendOnly {
c.builder.CreateCall(selectsend, []llvm.Value{selectp, ch, ptrs[i]}, "")
} else {
c.builder.CreateCall(selectrecv, []llvm.Value{selectp, ch, ptrs[i], received}, "")
}
}
// Fire off the select.
index := c.builder.CreateCall(c.runtime.selectgo.LLVMValue(), []llvm.Value{selectp}, "")
tuple := c.builder.CreateLoad(tupleptr, "")
tuple = c.builder.CreateInsertValue(tuple, index, 0, "")
return c.NewValue(tuple, resType)
}
func (c *compiler) NewConstValue(v exact.Value, typ types.Type) *LLVMValue {
switch {
case v == nil:
llvmtyp := c.types.ToLLVM(typ)
return c.NewValue(llvm.ConstNull(llvmtyp), typ)
case isString(typ):
if isUntyped(typ) {
typ = types.Typ[types.String]
}
llvmtyp := c.types.ToLLVM(typ)
strval := exact.StringVal(v)
strlen := len(strval)
i8ptr := llvm.PointerType(llvm.Int8Type(), 0)
var ptr llvm.Value
if strlen > 0 {
init := llvm.ConstString(strval, false)
ptr = llvm.AddGlobal(c.module.Module, init.Type(), "")
ptr.SetInitializer(init)
ptr = llvm.ConstBitCast(ptr, i8ptr)
} else {
ptr = llvm.ConstNull(i8ptr)
}
len_ := llvm.ConstInt(c.types.inttype, uint64(strlen), false)
llvmvalue := llvm.Undef(llvmtyp)
llvmvalue = llvm.ConstInsertValue(llvmvalue, ptr, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, len_, []uint32{1})
return c.NewValue(llvmvalue, typ)
case isInteger(typ):
if isUntyped(typ) {
typ = types.Typ[types.Int]
}
llvmtyp := c.types.ToLLVM(typ)
var llvmvalue llvm.Value
if isUnsigned(typ) {
v, _ := exact.Uint64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, v, false)
} else {
v, _ := exact.Int64Val(v)
llvmvalue = llvm.ConstInt(llvmtyp, uint64(v), true)
}
return c.NewValue(llvmvalue, typ)
case isBoolean(typ):
if isUntyped(typ) {
typ = types.Typ[types.Bool]
}
var llvmvalue llvm.Value
if exact.BoolVal(v) {
llvmvalue = llvm.ConstAllOnes(llvm.Int1Type())
} else {
llvmvalue = llvm.ConstNull(llvm.Int1Type())
}
return c.NewValue(llvmvalue, typ)
case isFloat(typ):
if isUntyped(typ) {
typ = types.Typ[types.Float64]
}
llvmtyp := c.types.ToLLVM(typ)
floatval, _ := exact.Float64Val(v)
llvmvalue := llvm.ConstFloat(llvmtyp, floatval)
return c.NewValue(llvmvalue, typ)
case typ == types.Typ[types.UnsafePointer]:
llvmtyp := c.types.ToLLVM(typ)
v, _ := exact.Uint64Val(v)
llvmvalue := llvm.ConstInt(llvmtyp, v, false)
return c.NewValue(llvmvalue, typ)
case isComplex(typ):
if isUntyped(typ) {
typ = types.Typ[types.Complex128]
}
llvmtyp := c.types.ToLLVM(typ)
floattyp := llvmtyp.StructElementTypes()[0]
llvmvalue := llvm.ConstNull(llvmtyp)
realv := exact.Real(v)
imagv := exact.Imag(v)
realfloatval, _ := exact.Float64Val(realv)
imagfloatval, _ := exact.Float64Val(imagv)
llvmre := llvm.ConstFloat(floattyp, realfloatval)
llvmim := llvm.ConstFloat(floattyp, imagfloatval)
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmre, []uint32{0})
llvmvalue = llvm.ConstInsertValue(llvmvalue, llvmim, []uint32{1})
return c.NewValue(llvmvalue, typ)
}
// Special case for string -> [](byte|rune)
if u, ok := typ.Underlying().(*types.Slice); ok && isInteger(u.Elem()) {
if v.Kind() == exact.String {
strval := c.NewConstValue(v, types.Typ[types.String])
return strval.Convert(typ).(*LLVMValue)
}
}
panic(fmt.Sprintf("unhandled: t=%s(%T), v=%v(%T)", typ, typ, v, v))
}
// 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
}