func main() { flag.Parse() if triple == "" { log.Fatal("No default triple set") } if clang == "" { clang = "clang" } llgobuildctx, err := llgobuild.ContextFromTriple(triple) if err != nil { log.Fatal(err) } buildctx = &llgobuildctx.Context // pkgroot = $GOPATH/pkg/llgo/<triple> gopath := os.Getenv("GOPATH") if gopath == "" { gopath = runtime.GOROOT() } else { gopath = filepath.SplitList(gopath)[0] } pkgroot = filepath.Join(gopath, "pkg", "llgo", triple) // Create a temporary work dir. workdir, err = ioutil.TempDir("", "llgo") if err != nil { log.Fatal(err) } if work { log.Println("Working directory:", workdir) } args := flag.Args() if test { if len(args) > 1 { err = fmt.Errorf("Multiple files/packages can not be specified when building a test binary") } else { err = buildPackageTests(args[0]) } } else { err = buildPackages(args) } if !work { os.RemoveAll(workdir) } if err != nil { log.Fatal(err) } }
func buildLlgo() error { log.Println("Building llgo") cmd := command("go", "get", "-d", gollvmpkgpath) output, err := cmd.CombinedOutput() if err != nil { fmt.Fprintf(os.Stderr, "%s\n", string(output)) return err } pkg, err := gobuild.Import(gollvmpkgpath, "", gobuild.FindOnly) if err != nil { return err } if alwaysbuild { if _, err := os.Stat(pkg.PkgObj); err == nil { log.Println("- Rebuilding gollvm") os.Remove(pkg.PkgObj) } } cgoCflags := fmt.Sprintf("%s -I %s/../include", llvmcflags, pkg.Dir) cgoLdflags := fmt.Sprintf("-Wl,-L%s", llvmlibdir) ldflags := fmt.Sprintf("-r %q", llvmlibdir) if sharedllvm { cgoLdflags += fmt.Sprintf(" -lLLVM-%s ", llvmversion) } else { cgoLdflags += " " + llvmlibs + " -lstdc++ -lm " } cgoLdflags += " " + llvmldflags args := []string{"get", "-ldflags", ldflags} llvmtag := "llvm" + llvmversion if strings.HasSuffix(llvmversion, "svn") { llvmtag = "llvmsvn" } args = append(args, []string{"-tags", llvmtag}...) args = append(args, llgopkgpath) cmd = command("go", args...) cmd.Env = os.Environ() cmd.Env = append(cmd.Env, "CGO_CFLAGS="+cgoCflags) cmd.Env = append(cmd.Env, "CGO_LDFLAGS="+cgoLdflags) output, err = cmd.CombinedOutput() if err != nil { fmt.Fprintf(os.Stderr, "%s\n", string(output)) return err } pkg, err = gobuild.Import(llgopkgpath, "", gobuild.FindOnly) if err != nil { return err } llgobin = path.Join(pkg.BinDir, "llgo") // If the user did not specify -triple on the command // line, ask llgo for it now. if triple == "" { output, err = command(llgobin, "-print-triple").CombinedOutput() if err != nil { fmt.Fprintf(os.Stderr, "%s\n", string(output)) return err } triple = strings.TrimSpace(string(output)) } llgobuildctx, err := build.ContextFromTriple(triple) if err != nil { return err } buildctx = &llgobuildctx.Context log.Printf("GOARCH = %s, GOOS = %s", buildctx.GOARCH, buildctx.GOOS) log.Printf("Built %s", llgobin) if install_name_tool && sharedllvm { // TODO: this was with the LLVM shipped with the pnacl sdk and might not be true of *all* libLLVM-xxx.dylibs. // Is there a link time commandline option that has the same effect? cmd = command("install_name_tool", "-change", fmt.Sprintf("@executable_path/../lib/libLLVM-%s.dylib", llvmversion), fmt.Sprintf("%s/libLLVM-%s.dylib", llvmlibdir, llvmversion), llgobin) output, err = cmd.CombinedOutput() if err != nil { fmt.Fprintf(os.Stderr, "%s\n", string(output)) return err } log.Printf("Successfully changed shared libLLVM path") } return nil }
func (compiler *compiler) compile(filenames []string, importpath string) (m *Module, err error) { buildctx, err := llgobuild.ContextFromTriple(compiler.TargetTriple) if err != nil { return nil, err } impcfg := &loader.Config{ Fset: token.NewFileSet(), TypeChecker: types.Config{ Import: llgoimporter.NewImporter(buildctx).Import, Sizes: compiler.llvmtypes, }, Build: &buildctx.Context, } // Must use parseFiles, so we retain comments; // this is important for annotation processing. astFiles, err := parseFiles(impcfg.Fset, filenames) if err != nil { return nil, err } // If no import path is specified, or the package's // name (not path) is "main", then set the import // path to be the same as the package's name. if pkgname := astFiles[0].Name.String(); importpath == "" || pkgname == "main" { importpath = pkgname } impcfg.CreateFromFiles(importpath, astFiles...) // Create a "runtime" package too, so we can reference // its types and functions in the compiler and generated // code. if importpath != "runtime" { astFiles, err := parseRuntime(&buildctx.Context, impcfg.Fset) if err != nil { return nil, err } impcfg.CreateFromFiles("runtime", astFiles...) } iprog, err := impcfg.Load() if err != nil { return nil, err } program := ssa.Create(iprog, 0) var mainPkginfo, runtimePkginfo *loader.PackageInfo if pkgs := iprog.InitialPackages(); len(pkgs) == 1 { mainPkginfo, runtimePkginfo = pkgs[0], pkgs[0] } else { mainPkginfo, runtimePkginfo = pkgs[0], pkgs[1] } mainPkg := program.CreatePackage(mainPkginfo) // Create a Module, which contains the LLVM bitcode. modulename := importpath compiler.module = &Module{Module: llvm.NewModule(modulename), Name: modulename} compiler.module.SetTarget(compiler.TargetTriple) compiler.module.SetDataLayout(compiler.dataLayout) // Create a new translation unit. unit := newUnit(compiler, mainPkg) // Create the runtime interface. compiler.runtime, err = newRuntimeInterface( runtimePkginfo.Pkg, compiler.module.Module, compiler.llvmtypes, FuncResolver(unit), ) if err != nil { return nil, err } // Create a struct responsible for mapping static types to LLVM types, // and to runtime/dynamic type values. compiler.types = NewTypeMap( importpath, compiler.llvmtypes, compiler.module.Module, compiler.runtime, MethodResolver(unit), ) // Create a Builder, for building LLVM instructions. compiler.builder = llvm.GlobalContext().NewBuilder() defer compiler.builder.Dispose() // Initialise debugging. compiler.debug.module = compiler.module.Module compiler.debug.Fset = impcfg.Fset compiler.debug.Sizes = compiler.llvmtypes mainPkg.Build() unit.translatePackage(mainPkg) compiler.processAnnotations(unit, mainPkginfo) if runtimePkginfo != mainPkginfo { compiler.processAnnotations(unit, runtimePkginfo) } // Finalise debugging. for _, cu := range compiler.debug.cu { compiler.module.AddNamedMetadataOperand( "llvm.dbg.cu", compiler.debug.MDNode(cu), ) } // Export runtime type information. var exportedTypes []types.Type for _, m := range mainPkg.Members { if t, ok := m.(*ssa.Type); ok && ast.IsExported(t.Name()) { exportedTypes = append(exportedTypes, t.Type()) } } compiler.exportRuntimeTypes(exportedTypes, importpath == "runtime") if importpath == "main" { // Wrap "main.main" in a call to runtime.main. if err = compiler.createMainFunction(); err != nil { return nil, fmt.Errorf("failed to create main.main: %v", err) } } else { if err := llgoimporter.Export(buildctx, mainPkg.Object); err != nil { return nil, fmt.Errorf("failed to export package data: %v", err) } } return compiler.module, nil }
func (compiler *compiler) Compile(filenames []string, importpath string) (m *Module, err error) { // FIXME create a compilation state, rather than storing in 'compiler'. compiler.llvmtypes = NewLLVMTypeMap(compiler.target) buildctx, err := llgobuild.ContextFromTriple(compiler.TargetTriple) if err != nil { return nil, err } impcfg := &goimporter.Config{ TypeChecker: types.Config{ Import: llgoimporter.NewImporter(buildctx).Import, Sizes: compiler.llvmtypes, }, Build: &buildctx.Context, } compiler.typechecker = &impcfg.TypeChecker compiler.importer = goimporter.New(impcfg) program := ssa.NewProgram(compiler.importer.Fset, 0) astFiles, err := parseFiles(compiler.importer.Fset, filenames) if err != nil { return nil, err } // If no import path is specified, or the package's // name (not path) is "main", then set the import // path to be the same as the package's name. if pkgname := astFiles[0].Name.String(); importpath == "" || pkgname == "main" { importpath = pkgname } mainPkginfo := compiler.importer.CreatePackage(importpath, astFiles...) if mainPkginfo.Err != nil { return nil, mainPkginfo.Err } // First call CreatePackages to resolve imports, and then CreatePackage // to obtain the main package. The latter simply returns the package // created by the former. if err := program.CreatePackages(compiler.importer); err != nil { return nil, err } mainpkg := program.CreatePackage(mainPkginfo) // Create a Module, which contains the LLVM bitcode. Dispose it on panic, // otherwise we'll set a finalizer at the end. The caller may invoke // Dispose manually, which will render the finalizer a no-op. modulename := importpath compiler.module = &Module{llvm.NewModule(modulename), modulename, false} compiler.module.SetTarget(compiler.TargetTriple) compiler.module.SetDataLayout(compiler.target.String()) // Map runtime types and functions. runtimePkginfo := mainPkginfo runtimePkg := mainpkg if importpath != "runtime" { astFiles, err := parseRuntime(&buildctx.Context, compiler.importer.Fset) if err != nil { return nil, err } runtimePkginfo = compiler.importer.CreatePackage("runtime", astFiles...) if runtimePkginfo.Err != nil { return nil, err } runtimePkg = program.CreatePackage(runtimePkginfo) } // Create a new translation unit. unit := newUnit(compiler, mainpkg) // Create the runtime interface. compiler.runtime, err = newRuntimeInterface( runtimePkg.Object, compiler.module.Module, compiler.llvmtypes, FuncResolver(unit), ) if err != nil { return nil, err } // Create a struct responsible for mapping static types to LLVM types, // and to runtime/dynamic type values. compiler.types = NewTypeMap( importpath, compiler.llvmtypes, compiler.module.Module, compiler.runtime, MethodResolver(unit), ) // Create a Builder, for building LLVM instructions. compiler.builder = llvm.GlobalContext().NewBuilder() defer compiler.builder.Dispose() mainpkg.Build() unit.translatePackage(mainpkg) compiler.processAnnotations(unit, mainPkginfo) if runtimePkginfo != mainPkginfo { compiler.processAnnotations(unit, runtimePkginfo) } /* compiler.debug_info = &llvm.DebugInfo{} // Compile each file in the package. for _, file := range files { if compiler.GenerateDebug { cu := &llvm.CompileUnitDescriptor{ Language: llvm.DW_LANG_Go, Path: llvm.FileDescriptor(fset.File(file.Pos()).Name()), Producer: LLGOProducer, Runtime: LLGORuntimeVersion, } compiler.pushDebugContext(cu) compiler.pushDebugContext(&cu.Path) } for _, decl := range file.Decls { compiler.VisitDecl(decl) } if compiler.GenerateDebug { compiler.popDebugContext() cu := compiler.popDebugContext() if len(compiler.debug_context) > 0 { log.Panicln(compiler.debug_context) } compiler.module.AddNamedMetadataOperand( "llvm.dbg.cu", compiler.debug_info.MDNode(cu), ) } } */ // Export runtime type information. var exportedTypes []types.Type for _, m := range mainpkg.Members { if t, ok := m.(*ssa.Type); ok && ast.IsExported(t.Name()) { exportedTypes = append(exportedTypes, t.Type()) } } compiler.exportRuntimeTypes(exportedTypes, importpath == "runtime") if importpath == "main" { // Wrap "main.main" in a call to runtime.main. if err = compiler.createMainFunction(); err != nil { return nil, fmt.Errorf("failed to create main.main: %v", err) } } else { if err := llgoimporter.Export(buildctx, mainpkg.Object); err != nil { return nil, fmt.Errorf("failed to export package data: %v", err) } } return compiler.module, nil }