func (v *Codegen) Generate(input []*parser.Module, modules map[string]*parser.Module, verbose bool) {
v.input = input
v.builder = llvm.NewBuilder()
v.variableLookup = make(map[*parser.Variable]llvm.Value)
v.structLookup_UseHelperFunction = make(map[*parser.StructType]llvm.Type)
if verbose {
fmt.Println(util.TEXT_BOLD + util.TEXT_GREEN + "Started codegenning" + util.TEXT_RESET)
}
t := time.Now()
passManager := llvm.NewPassManager()
passBuilder := llvm.NewPassManagerBuilder()
passBuilder.SetOptLevel(3)
//passBuilder.Populate(passManager) //leave this off until the compiler is better
v.modules = make(map[string]*parser.Module)
for _, infile := range input {
infile.Module = llvm.NewModule(infile.Name)
v.curFile = infile
fmt.Println("adding module " + v.curFile.Name)
v.modules[v.curFile.Name] = v.curFile
v.declareDecls(infile.Nodes)
for _, node := range infile.Nodes {
v.genNode(node)
}
if verbose {
infile.Module.Dump()
}
if err := llvm.VerifyModule(infile.Module, llvm.ReturnStatusAction); err != nil {
v.err("%s", err.Error())
}
passManager.Run(infile.Module)
}
passManager.Dispose()
v.createBinary()
dur := time.Since(t)
if verbose {
fmt.Printf(util.TEXT_BOLD+util.TEXT_GREEN+"Finished codegenning"+util.TEXT_RESET+" (%.2fms)\n",
float32(dur.Nanoseconds())/1000000)
}
}
func runPasses(opts *driverOptions, tm llvm.TargetMachine, m llvm.Module) {
fpm := llvm.NewFunctionPassManagerForModule(m)
defer fpm.Dispose()
mpm := llvm.NewPassManager()
defer mpm.Dispose()
pmb := llvm.NewPassManagerBuilder()
defer pmb.Dispose()
pmb.SetOptLevel(opts.optLevel)
pmb.SetSizeLevel(opts.sizeLevel)
target := tm.TargetData()
mpm.Add(target)
fpm.Add(target)
tm.AddAnalysisPasses(mpm)
tm.AddAnalysisPasses(fpm)
mpm.AddVerifierPass()
fpm.AddVerifierPass()
pmb.Populate(mpm)
pmb.PopulateFunc(fpm)
if opts.optLevel == 0 {
// Remove references (via the descriptor) to dead functions,
// for compatibility with other compilers.
mpm.AddGlobalDCEPass()
}
opts.sanitizer.addPasses(mpm, fpm)
fpm.InitializeFunc()
for fn := m.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
fpm.RunFunc(fn)
}
fpm.FinalizeFunc()
mpm.Run(m)
}
func (v *Codegen) Generate(input []*parser.Module) {
v.builders = make(map[*parser.Function]llvm.Builder)
v.inBlocks = make(map[*parser.Function][]*parser.Block)
v.globalBuilder = llvm.NewBuilder()
defer v.globalBuilder.Dispose()
v.curLoopExits = make(map[*parser.Function][]llvm.BasicBlock)
v.curLoopNexts = make(map[*parser.Function][]llvm.BasicBlock)
v.input = make([]*WrappedModule, len(input))
for idx, mod := range input {
v.input[idx] = &WrappedModule{Module: mod}
}
v.variableLookup = make(map[*parser.Variable]llvm.Value)
v.namedTypeLookup = make(map[string]llvm.Type)
// initialize llvm target
llvm.InitializeNativeTarget()
llvm.InitializeNativeAsmPrinter()
// setup target stuff
var err error
v.target, err = llvm.GetTargetFromTriple(llvm.DefaultTargetTriple())
if err != nil {
panic(err)
}
v.targetMachine = v.target.CreateTargetMachine(llvm.DefaultTargetTriple(), "", "", llvm.CodeGenLevelNone, llvm.RelocDefault, llvm.CodeModelDefault)
v.targetData = v.targetMachine.TargetData()
passManager := llvm.NewPassManager()
passBuilder := llvm.NewPassManagerBuilder()
if v.OptLevel > 0 {
passBuilder.SetOptLevel(v.OptLevel)
passBuilder.Populate(passManager)
}
v.blockDeferData = make(map[*parser.Block][]*deferData)
for _, infile := range v.input {
log.Timed("codegenning", infile.Name.String(), func() {
infile.LlvmModule = llvm.NewModule(infile.Name.String())
v.curFile = infile
for _, submod := range infile.Parts {
v.declareDecls(submod.Nodes)
for _, node := range submod.Nodes {
v.genNode(node)
}
}
if err := llvm.VerifyModule(infile.LlvmModule, llvm.ReturnStatusAction); err != nil {
infile.LlvmModule.Dump()
v.err("%s", err.Error())
}
passManager.Run(infile.LlvmModule)
if log.AtLevel(log.LevelDebug) {
infile.LlvmModule.Dump()
}
})
}
passManager.Dispose()
log.Timed("creating binary", "", func() {
v.createBinary()
})
}
func (v *Codegen) Generate(input []*parser.Module, modules map[string]*parser.Module) {
v.input = input
v.builder = llvm.NewBuilder()
v.variableLookup = make(map[*parser.Variable]llvm.Value)
v.structLookup_UseHelperFunction = make(map[*parser.StructType]llvm.Type)
v.enumLookup_UseHelperFunction = make(map[*parser.EnumType]llvm.Type)
// initialize llvm target
llvm.InitializeNativeTarget()
// setup target stuff
var err error
v.target, err = llvm.GetTargetFromTriple(llvm.DefaultTargetTriple())
if err != nil {
panic(err)
}
v.targetMachine = v.target.CreateTargetMachine(llvm.DefaultTargetTriple(), "", "", llvm.CodeGenLevelNone, llvm.RelocDefault, llvm.CodeModelDefault)
v.targetData = v.targetMachine.TargetData()
passManager := llvm.NewPassManager()
passBuilder := llvm.NewPassManagerBuilder()
if v.OptLevel > 0 {
passBuilder.SetOptLevel(v.OptLevel)
passBuilder.Populate(passManager)
}
v.modules = make(map[string]*parser.Module)
v.blockDeferData = make(map[*parser.Block][]*deferData)
for _, infile := range input {
log.Verboseln("codegen", util.TEXT_BOLD+util.TEXT_GREEN+"Started codegenning "+util.TEXT_RESET+infile.Name)
t := time.Now()
infile.Module = llvm.NewModule(infile.Name)
v.curFile = infile
v.modules[v.curFile.Name] = v.curFile
v.declareDecls(infile.Nodes)
for _, node := range infile.Nodes {
v.genNode(node)
}
if err := llvm.VerifyModule(infile.Module, llvm.ReturnStatusAction); err != nil {
infile.Module.Dump()
v.err("%s", err.Error())
}
passManager.Run(infile.Module)
if log.AtLevel(log.LevelVerbose) {
infile.Module.Dump()
}
dur := time.Since(t)
log.Verbose("codegen", util.TEXT_BOLD+util.TEXT_GREEN+"Finished codegenning "+util.TEXT_RESET+infile.Name+" (%.2fms)\n",
float32(dur.Nanoseconds())/1000000)
}
passManager.Dispose()
log.Timed("create binary", func() {
v.createBinary()
})
}