130 lines
2.9 KiB
Go
130 lines
2.9 KiB
Go
package vm
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"sync"
|
|
|
|
"github.com/mediocregopher/ginger/lang"
|
|
|
|
"llvm.org/llvm/bindings/go/llvm"
|
|
)
|
|
|
|
// Types supported by the vm in addition to those which are part of lang
|
|
var (
|
|
Atom = lang.AAtom
|
|
Tuple = lang.ATuple
|
|
Int = lang.Atom("int")
|
|
)
|
|
|
|
// Ops supported by the vm
|
|
var (
|
|
Add = lang.Atom("add")
|
|
Assign = lang.Atom("assign")
|
|
Var = lang.Atom("var")
|
|
)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// 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
|
|
ctx varCtx
|
|
mainFn llvm.Value
|
|
}
|
|
|
|
var initOnce sync.Once
|
|
|
|
// Build creates a new Module by compiling the given Terms as code
|
|
// TODO only take in a single Term, implement List and use that with a do op
|
|
func Build(tt ...lang.Term) (*Module, error) {
|
|
initOnce.Do(func() {
|
|
llvm.LinkInMCJIT()
|
|
llvm.InitializeNativeTarget()
|
|
llvm.InitializeNativeAsmPrinter()
|
|
})
|
|
mod := &Module{
|
|
b: llvm.NewBuilder(),
|
|
m: llvm.NewModule(""),
|
|
ctx: varCtx{},
|
|
}
|
|
|
|
var err error
|
|
if mod.mainFn, err = mod.buildFn(tt...); 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()
|
|
}
|
|
|
|
// 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")
|
|
}
|
|
|
|
ops := make([]op, len(tt))
|
|
var err error
|
|
for i := range tt {
|
|
if ops[i], err = termToOp(mod.ctx, tt[i]); err != nil {
|
|
return llvm.Value{}, err
|
|
}
|
|
}
|
|
|
|
var llvmIns []llvm.Type
|
|
if in := ops[0].inType(); in.llvm.TypeKind() == llvm.VoidTypeKind {
|
|
llvmIns = []llvm.Type{}
|
|
} else {
|
|
llvmIns = []llvm.Type{in.llvm}
|
|
}
|
|
llvmOut := ops[len(ops)-1].outType().llvm
|
|
|
|
fn := llvm.AddFunction(mod.m, "", llvm.FunctionType(llvmOut, llvmIns, false))
|
|
block := llvm.AddBasicBlock(fn, "")
|
|
mod.b.SetInsertPoint(block, block.FirstInstruction())
|
|
|
|
var out llvm.Value
|
|
for i := range ops {
|
|
if out, err = ops[i].build(mod); err != nil {
|
|
return llvm.Value{}, err
|
|
}
|
|
}
|
|
mod.b.CreateRet(out)
|
|
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
|
|
}
|