ginger/vm/vm.go
2017-02-12 08:55:27 -07:00

152 lines
3.2 KiB
Go

package vm
import (
"errors"
"fmt"
"sync"
"github.com/mediocregopher/ginger/lang"
"llvm.org/llvm/bindings/go/llvm"
)
type val struct {
typ lang.Term
v llvm.Value
}
// Module contains a compiled set of code which can be run, dumped in IR form,
// or compiled. A Module should be Dispose()'d of once it's no longer being
// used.
type Module struct {
b llvm.Builder
m llvm.Module
mainFn llvm.Value
buildCmds []buildCmd
}
var initOnce sync.Once
// Build creates a new Module by compiling the given Term as code
func Build(t lang.Term) (*Module, error) {
initOnce.Do(func() {
llvm.LinkInMCJIT()
llvm.InitializeNativeTarget()
llvm.InitializeNativeAsmPrinter()
})
mod := &Module{
b: llvm.NewBuilder(),
m: llvm.NewModule(""),
}
mod.buildCmds = buildCmds(mod)
var err error
if mod.mainFn, err = mod.buildFn(t); err != nil {
mod.Dispose()
return nil, err
}
if err := llvm.VerifyModule(mod.m, llvm.ReturnStatusAction); err != nil {
mod.Dispose()
return nil, fmt.Errorf("could not verify module: %s", err)
}
return mod, nil
}
// Dispose cleans up all resources held by the Module
func (mod *Module) Dispose() {
// TODO this panics for some reason...
//mod.m.Dispose()
//mod.b.Dispose()
}
func (mod *Module) matchingBuildCmd(t lang.Term) (buildCmd, error) {
for _, cmd := range mod.buildCmds {
if !cmd.matches(t) {
continue
}
return cmd, nil
}
return buildCmd{}, fmt.Errorf("unknown compiler command %v", t)
}
func (mod *Module) inType(t lang.Term) (llvm.Type, error) {
cmd, err := mod.matchingBuildCmd(t)
if err != nil {
return llvm.Type{}, err
}
return cmd.inType(t.(lang.Tuple)[1])
}
func (mod *Module) outType(t lang.Term) (llvm.Type, error) {
cmd, err := mod.matchingBuildCmd(t)
if err != nil {
return llvm.Type{}, err
}
return cmd.outType(t.(lang.Tuple)[1])
}
func (mod *Module) build(t lang.Term) (val, error) {
cmd, err := mod.matchingBuildCmd(t)
if err != nil {
return val{}, err
}
return cmd.build(t.(lang.Tuple)[1])
}
// TODO make this return a val once we get function types
func (mod *Module) buildFn(tt ...lang.Term) (llvm.Value, error) {
if len(tt) == 0 {
return llvm.Value{}, errors.New("function cannot be empty")
}
inType, err := mod.inType(tt[0])
if err != nil {
return llvm.Value{}, err
}
var inTypes []llvm.Type
if inType.TypeKind() == llvm.VoidTypeKind {
inTypes = []llvm.Type{}
} else {
inTypes = []llvm.Type{inType}
}
outType, err := mod.outType(tt[len(tt)-1])
if err != nil {
return llvm.Value{}, err
}
fn := llvm.AddFunction(mod.m, "", llvm.FunctionType(outType, inTypes, false))
block := llvm.AddBasicBlock(fn, "")
mod.b.SetInsertPoint(block, block.FirstInstruction())
var out val
for _, t := range tt {
if out, err = mod.build(t); err != nil {
return llvm.Value{}, err
}
}
mod.b.CreateRet(out.v)
return fn, nil
}
// Dump dumps the Module's IR to stdout
func (mod *Module) Dump() {
mod.m.Dump()
}
// Run executes the Module
// TODO input and output?
func (mod *Module) Run() (interface{}, error) {
engine, err := llvm.NewExecutionEngine(mod.m)
if err != nil {
return nil, err
}
defer engine.Dispose()
funcResult := engine.RunFunction(mod.mainFn, []llvm.GenericValue{})
defer funcResult.Dispose()
return funcResult.Int(false), nil
}