// makeSlice allocates a new slice with the optional length and capacity,
// initialising its contents to their zero values.
func (c *compiler) makeSlice(elttyp types.Type, length, capacity Value) llvm.Value {
var lengthValue llvm.Value
if length != nil {
lengthValue = length.Convert(types.Int32).LLVMValue()
} else {
lengthValue = llvm.ConstNull(llvm.Int32Type())
}
// TODO check capacity >= length
capacityValue := lengthValue
if capacity != nil {
capacityValue = capacity.Convert(types.Int32).LLVMValue()
}
eltType := c.types.ToLLVM(elttyp)
sizeof := llvm.ConstTrunc(llvm.SizeOf(eltType), llvm.Int32Type())
size := c.builder.CreateMul(capacityValue, sizeof, "")
mem := c.createMalloc(c.NewLLVMValue(size, types.Int32).Convert(types.Uintptr).LLVMValue())
mem = c.builder.CreateIntToPtr(mem, llvm.PointerType(eltType, 0), "")
c.memsetZero(mem, size)
slicetyp := types.Slice{Elt: elttyp}
struct_ := llvm.Undef(c.types.ToLLVM(&slicetyp))
struct_ = c.builder.CreateInsertValue(struct_, mem, 0, "")
struct_ = c.builder.CreateInsertValue(struct_, lengthValue, 1, "")
struct_ = c.builder.CreateInsertValue(struct_, capacityValue, 2, "")
return struct_
}
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.
lt := tm.ToLLVM(t)
typ := llvm.ConstNull(tm.runtimeType)
elementTypes := tm.runtimeType.StructElementTypes()
// Size.
size := llvm.SizeOf(lt)
if size.Type().IntTypeWidth() > elementTypes[0].IntTypeWidth() {
size = llvm.ConstTrunc(size, elementTypes[0])
}
typ = llvm.ConstInsertValue(typ, size, []uint32{0})
// TODO hash
// TODO padding
// Alignment.
align := llvm.ConstTrunc(llvm.AlignOf(lt), llvm.Int8Type())
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(tm.TypeString(t))
typ = llvm.ConstInsertValue(typ, stringrep, []uint32{8})
// TODO gc
return typ
}
func (c *compiler) VisitGoStmt(stmt *ast.GoStmt) {
//stmt.Call *ast.CallExpr
// TODO
var fn *LLVMValue
switch x := (stmt.Call.Fun).(type) {
case *ast.Ident:
fn = c.Resolve(x.Obj).(*LLVMValue)
if fn == nil {
panic(fmt.Sprintf(
"No function found with name '%s'", x.String()))
}
default:
fn = c.VisitExpr(stmt.Call.Fun).(*LLVMValue)
}
// Evaluate arguments, store in a structure on the stack.
var args_struct_type llvm.Type
var args_mem llvm.Value
var args_size llvm.Value
if stmt.Call.Args != nil {
param_types := make([]llvm.Type, 0)
fn_type := types.Deref(fn.Type()).(*types.Func)
for _, param := range fn_type.Params {
typ := param.Type.(types.Type)
param_types = append(param_types, c.types.ToLLVM(typ))
}
args_struct_type = llvm.StructType(param_types, false)
args_mem = c.builder.CreateAlloca(args_struct_type, "")
for i, expr := range stmt.Call.Args {
value_i := c.VisitExpr(expr)
value_i = value_i.Convert(fn_type.Params[i].Type.(types.Type))
arg_i := c.builder.CreateGEP(args_mem, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), uint64(i), false)}, "")
c.builder.CreateStore(value_i.LLVMValue(), arg_i)
}
args_size = llvm.SizeOf(args_struct_type)
args_size = llvm.ConstTrunc(args_size, llvm.Int32Type())
} else {
args_struct_type = llvm.VoidType()
args_mem = llvm.ConstNull(llvm.PointerType(args_struct_type, 0))
args_size = llvm.ConstInt(llvm.Int32Type(), 0, false)
}
// When done, return to where we were.
defer c.builder.SetInsertPointAtEnd(c.builder.GetInsertBlock())
// 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.
indirect_fn_type := llvm.FunctionType(
llvm.VoidType(),
[]llvm.Type{llvm.PointerType(args_struct_type, 0)}, false)
indirect_fn := llvm.AddFunction(c.module.Module, "", indirect_fn_type)
indirect_fn.SetFunctionCallConv(llvm.CCallConv)
// Call "newgoroutine" with the indirect function and stored args.
newgoroutine := getnewgoroutine(c.module.Module)
ngr_param_types := newgoroutine.Type().ElementType().ParamTypes()
fn_arg := c.builder.CreateBitCast(indirect_fn, ngr_param_types[0], "")
args_arg := c.builder.CreateBitCast(args_mem,
llvm.PointerType(llvm.Int8Type(), 0), "")
c.builder.CreateCall(newgoroutine,
[]llvm.Value{fn_arg, args_arg, args_size}, "")
entry := llvm.AddBasicBlock(indirect_fn, "entry")
c.builder.SetInsertPointAtEnd(entry)
var args []llvm.Value
if stmt.Call.Args != nil {
args_mem = indirect_fn.Param(0)
args = make([]llvm.Value, len(stmt.Call.Args))
for i := range stmt.Call.Args {
arg_i := c.builder.CreateGEP(args_mem, []llvm.Value{
llvm.ConstInt(llvm.Int32Type(), 0, false),
llvm.ConstInt(llvm.Int32Type(), uint64(i), false)}, "")
args[i] = c.builder.CreateLoad(arg_i, "")
}
}
c.builder.CreateCall(fn.LLVMValue(), args, "")
c.builder.CreateRetVoid()
}