8e6cb89ceb
This is a large commit that moves all code directly related to
compiling/linking into a new builder package. This has a number of
advantages:
* It cleanly separates the API between the command line and the full
compilation (with a very small API surface).
* When the compiler finally compiles one package at a time (instead of
everything at once as it does now), something will have to invoke it
once per package. This builder package will be the natural place to
do that, and also be the place where the whole process can be
parallelized.
* It allows the TinyGo compiler to be used as a package. A client can
simply import the builder package and compile code using it.
As part of this refactor, the following additional things changed:
* Exported symbols have been made unexported when they weren't needed.
* The compilation target has been moved into the compileopts.Options
struct. This is done because the target really is just another
compiler option, and the API is simplified by moving it in there.
* The moveFile function has been duplicated. It does not really belong
in the builder API but is used both by the builder and the command
line. Moving it into a separate package didn't seem useful either
for what is essentially an utility function.
* Some doc strings have been improved.
Some future changes/refactors I'd like to make after this commit:
* Clean up the API between the builder and the compiler package.
* Perhaps move the test files (in testdata/) into the builder package.
* Perhaps move the loader package into the builder package.
114 строки
3,4 КиБ
Go
114 строки
3,4 КиБ
Go
package builder
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
// getGorootVersion returns the major and minor version for a given GOROOT path.
|
|
// If the goroot cannot be determined, (0, 0) is returned.
|
|
func getGorootVersion(goroot string) (major, minor int, err error) {
|
|
s, err := GorootVersionString(goroot)
|
|
if err != nil {
|
|
return 0, 0, err
|
|
}
|
|
|
|
if s == "" || s[:2] != "go" {
|
|
return 0, 0, errors.New("could not parse Go version: version does not start with 'go' prefix")
|
|
}
|
|
|
|
parts := strings.Split(s[2:], ".")
|
|
if len(parts) < 2 {
|
|
return 0, 0, errors.New("could not parse Go version: version has less than two parts")
|
|
}
|
|
|
|
// Ignore the errors, we don't really handle errors here anyway.
|
|
var trailing string
|
|
n, err := fmt.Sscanf(s, "go%d.%d%s", &major, &minor, &trailing)
|
|
if n == 2 && err == io.EOF {
|
|
// Means there were no trailing characters (i.e., not an alpha/beta)
|
|
err = nil
|
|
}
|
|
if err != nil {
|
|
return 0, 0, fmt.Errorf("failed to parse version: %s", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// GorootVersionString returns the version string as reported by the Go
|
|
// toolchain for the given GOROOT path. It is usually of the form `go1.x.y` but
|
|
// can have some variations (for beta releases, for example).
|
|
func GorootVersionString(goroot string) (string, error) {
|
|
if data, err := ioutil.ReadFile(filepath.Join(
|
|
goroot, "src", "runtime", "internal", "sys", "zversion.go")); err == nil {
|
|
|
|
r := regexp.MustCompile("const TheVersion = `(.*)`")
|
|
matches := r.FindSubmatch(data)
|
|
if len(matches) != 2 {
|
|
return "", errors.New("Invalid go version output:\n" + string(data))
|
|
}
|
|
|
|
return string(matches[1]), nil
|
|
|
|
} else if data, err := ioutil.ReadFile(filepath.Join(goroot, "VERSION")); err == nil {
|
|
return string(data), nil
|
|
|
|
} else {
|
|
return "", err
|
|
}
|
|
}
|
|
|
|
// getClangHeaderPath returns the path to the built-in Clang headers. It tries
|
|
// multiple locations, which should make it find the directory when installed in
|
|
// various ways.
|
|
func getClangHeaderPath(TINYGOROOT string) string {
|
|
// Check whether we're running from the source directory.
|
|
path := filepath.Join(TINYGOROOT, "llvm", "tools", "clang", "lib", "Headers")
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
return path
|
|
}
|
|
|
|
// Check whether we're running from the installation directory.
|
|
path = filepath.Join(TINYGOROOT, "lib", "clang", "include")
|
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
|
return path
|
|
}
|
|
|
|
// It looks like we are built with a system-installed LLVM. Do a last
|
|
// attempt: try to use Clang headers relative to the clang binary.
|
|
for _, cmdName := range commands["clang"] {
|
|
binpath, err := exec.LookPath(cmdName)
|
|
if err == nil {
|
|
// This should be the command that will also be used by
|
|
// execCommand. To avoid inconsistencies, make sure we use the
|
|
// headers relative to this command.
|
|
binpath, err = filepath.EvalSymlinks(binpath)
|
|
if err != nil {
|
|
// Unexpected.
|
|
return ""
|
|
}
|
|
// Example executable:
|
|
// /usr/lib/llvm-8/bin/clang
|
|
// Example include path:
|
|
// /usr/lib/llvm-8/lib/clang/8.0.1/include/
|
|
llvmRoot := filepath.Dir(filepath.Dir(binpath))
|
|
clangVersionRoot := filepath.Join(llvmRoot, "lib", "clang")
|
|
dirnames, err := ioutil.ReadDir(clangVersionRoot)
|
|
if err != nil || len(dirnames) != 1 {
|
|
// Unexpected.
|
|
return ""
|
|
}
|
|
return filepath.Join(clangVersionRoot, dirnames[0].Name(), "include")
|
|
}
|
|
}
|
|
|
|
// Could not find it.
|
|
return ""
|
|
}
|