655075e5e0
This implements the block-based GC as a partially precise GC. This means that for most heap allocations it is known which words contain a pointer and which don't. This should in theory make the GC faster (because it can skip non-pointer object) and have fewer false positives in a GC cycle. It does however use a bit more RAM to store the layout of each object. Right now this GC seems to be slower than the conservative GC, but should be less likely to run out of memory as a result of false positives.
367 строки
12 КиБ
Go
367 строки
12 КиБ
Go
package compileopts
|
|
|
|
// This file loads a target specification from a JSON file.
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"reflect"
|
|
"runtime"
|
|
"strings"
|
|
|
|
"github.com/tinygo-org/tinygo/goenv"
|
|
)
|
|
|
|
// Target specification for a given target. Used for bare metal targets.
|
|
//
|
|
// The target specification is mostly inspired by Rust:
|
|
// https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/spec/struct.TargetOptions.html
|
|
// https://github.com/shepmaster/rust-arduino-blink-led-no-core-with-cargo/blob/master/blink/arduino.json
|
|
type TargetSpec struct {
|
|
Inherits []string `json:"inherits"`
|
|
Triple string `json:"llvm-target"`
|
|
CPU string `json:"cpu"`
|
|
ABI string `json:"target-abi"` // rougly equivalent to -mabi= flag
|
|
Features string `json:"features"`
|
|
GOOS string `json:"goos"`
|
|
GOARCH string `json:"goarch"`
|
|
BuildTags []string `json:"build-tags"`
|
|
GC string `json:"gc"`
|
|
Scheduler string `json:"scheduler"`
|
|
Serial string `json:"serial"` // which serial output to use (uart, usb, none)
|
|
Linker string `json:"linker"`
|
|
RTLib string `json:"rtlib"` // compiler runtime library (libgcc, compiler-rt)
|
|
Libc string `json:"libc"`
|
|
AutoStackSize *bool `json:"automatic-stack-size"` // Determine stack size automatically at compile time.
|
|
DefaultStackSize uint64 `json:"default-stack-size"` // Default stack size if the size couldn't be determined at compile time.
|
|
CFlags []string `json:"cflags"`
|
|
LDFlags []string `json:"ldflags"`
|
|
LinkerScript string `json:"linkerscript"`
|
|
ExtraFiles []string `json:"extra-files"`
|
|
RP2040BootPatch *bool `json:"rp2040-boot-patch"` // Patch RP2040 2nd stage bootloader checksum
|
|
Emulator string `json:"emulator"`
|
|
FlashCommand string `json:"flash-command"`
|
|
GDB []string `json:"gdb"`
|
|
PortReset string `json:"flash-1200-bps-reset"`
|
|
SerialPort []string `json:"serial-port"` // serial port IDs in the form "vid:pid"
|
|
FlashMethod string `json:"flash-method"`
|
|
FlashVolume string `json:"msd-volume-name"`
|
|
FlashFilename string `json:"msd-firmware-name"`
|
|
UF2FamilyID string `json:"uf2-family-id"`
|
|
BinaryFormat string `json:"binary-format"`
|
|
OpenOCDInterface string `json:"openocd-interface"`
|
|
OpenOCDTarget string `json:"openocd-target"`
|
|
OpenOCDTransport string `json:"openocd-transport"`
|
|
OpenOCDCommands []string `json:"openocd-commands"`
|
|
OpenOCDVerify *bool `json:"openocd-verify"` // enable verify when flashing with openocd
|
|
JLinkDevice string `json:"jlink-device"`
|
|
CodeModel string `json:"code-model"`
|
|
RelocationModel string `json:"relocation-model"`
|
|
WasmAbi string `json:"wasm-abi"`
|
|
}
|
|
|
|
// overrideProperties overrides all properties that are set in child into itself using reflection.
|
|
func (spec *TargetSpec) overrideProperties(child *TargetSpec) error {
|
|
specType := reflect.TypeOf(spec).Elem()
|
|
specValue := reflect.ValueOf(spec).Elem()
|
|
childValue := reflect.ValueOf(child).Elem()
|
|
|
|
for i := 0; i < specType.NumField(); i++ {
|
|
field := specType.Field(i)
|
|
src := childValue.Field(i)
|
|
dst := specValue.Field(i)
|
|
|
|
switch kind := field.Type.Kind(); kind {
|
|
case reflect.String: // for strings, just copy the field of child to spec if not empty
|
|
if src.Len() > 0 {
|
|
dst.Set(src)
|
|
}
|
|
case reflect.Uint, reflect.Uint32, reflect.Uint64: // for Uint, copy if not zero
|
|
if src.Uint() != 0 {
|
|
dst.Set(src)
|
|
}
|
|
case reflect.Ptr: // for pointers, copy if not nil
|
|
if !src.IsNil() {
|
|
dst.Set(src)
|
|
}
|
|
case reflect.Slice: // for slices, append the field and check for duplicates
|
|
dst.Set(reflect.AppendSlice(dst, src))
|
|
for i := 0; i < dst.Len(); i++ {
|
|
v := dst.Index(i).String()
|
|
for j := i + 1; j < dst.Len(); j++ {
|
|
w := dst.Index(j).String()
|
|
if v == w {
|
|
return fmt.Errorf("duplicate value '%s' in field %s", v, field.Name)
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
return fmt.Errorf("unknown field type: %s", kind)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// load reads a target specification from the JSON in the given io.Reader. It
|
|
// may load more targets specified using the "inherits" property.
|
|
func (spec *TargetSpec) load(r io.Reader) error {
|
|
err := json.NewDecoder(r).Decode(spec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// loadFromGivenStr loads the TargetSpec from the given string that could be:
|
|
// - targets/ directory inside the compiler sources
|
|
// - a relative or absolute path to custom (project specific) target specification .json file;
|
|
// the Inherits[] could contain the files from target folder (ex. stm32f4disco)
|
|
// as well as path to custom files (ex. myAwesomeProject.json)
|
|
func (spec *TargetSpec) loadFromGivenStr(str string) error {
|
|
path := ""
|
|
if strings.HasSuffix(str, ".json") {
|
|
path, _ = filepath.Abs(str)
|
|
} else {
|
|
path = filepath.Join(goenv.Get("TINYGOROOT"), "targets", strings.ToLower(str)+".json")
|
|
}
|
|
fp, err := os.Open(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer fp.Close()
|
|
return spec.load(fp)
|
|
}
|
|
|
|
// resolveInherits loads inherited targets, recursively.
|
|
func (spec *TargetSpec) resolveInherits() error {
|
|
// First create a new spec with all the inherited properties.
|
|
newSpec := &TargetSpec{}
|
|
for _, name := range spec.Inherits {
|
|
subtarget := &TargetSpec{}
|
|
err := subtarget.loadFromGivenStr(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = subtarget.resolveInherits()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = newSpec.overrideProperties(subtarget)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// When all properties are loaded, make sure they are properly inherited.
|
|
err := newSpec.overrideProperties(spec)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*spec = *newSpec
|
|
|
|
return nil
|
|
}
|
|
|
|
// Load a target specification.
|
|
func LoadTarget(options *Options) (*TargetSpec, error) {
|
|
if options.Target == "" {
|
|
// Configure based on GOOS/GOARCH environment variables (falling back to
|
|
// runtime.GOOS/runtime.GOARCH), and generate a LLVM target based on it.
|
|
var llvmarch string
|
|
switch options.GOARCH {
|
|
case "386":
|
|
llvmarch = "i386"
|
|
case "amd64":
|
|
llvmarch = "x86_64"
|
|
case "arm64":
|
|
llvmarch = "aarch64"
|
|
case "arm":
|
|
switch options.GOARM {
|
|
case "5":
|
|
llvmarch = "armv5"
|
|
case "6":
|
|
llvmarch = "armv6"
|
|
case "7":
|
|
llvmarch = "armv7"
|
|
default:
|
|
return nil, fmt.Errorf("invalid GOARM=%s, must be 5, 6, or 7", options.GOARM)
|
|
}
|
|
default:
|
|
llvmarch = options.GOARCH
|
|
}
|
|
llvmvendor := "unknown"
|
|
llvmos := options.GOOS
|
|
if llvmos == "darwin" {
|
|
// Use macosx* instead of darwin, otherwise darwin/arm64 will refer
|
|
// to iOS!
|
|
llvmos = "macosx10.12.0"
|
|
if llvmarch == "aarch64" {
|
|
// Looks like Apple prefers to call this architecture ARM64
|
|
// instead of AArch64.
|
|
llvmarch = "arm64"
|
|
llvmos = "macosx11.0.0"
|
|
}
|
|
llvmvendor = "apple"
|
|
}
|
|
// Target triples (which actually have four components, but are called
|
|
// triples for historical reasons) have the form:
|
|
// arch-vendor-os-environment
|
|
target := llvmarch + "-" + llvmvendor + "-" + llvmos
|
|
if options.GOOS == "windows" {
|
|
target += "-gnu"
|
|
} else if options.GOARCH == "arm" {
|
|
target += "-gnueabihf"
|
|
}
|
|
return defaultTarget(options.GOOS, options.GOARCH, target)
|
|
}
|
|
|
|
// See whether there is a target specification for this target (e.g.
|
|
// Arduino).
|
|
spec := &TargetSpec{}
|
|
err := spec.loadFromGivenStr(options.Target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Successfully loaded this target from a built-in .json file. Make sure
|
|
// it includes all parents as specified in the "inherits" key.
|
|
err = spec.resolveInherits()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s : %w", options.Target, err)
|
|
}
|
|
|
|
if spec.Scheduler == "asyncify" {
|
|
spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_asyncify_wasm.S")
|
|
}
|
|
|
|
return spec, nil
|
|
}
|
|
|
|
func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
|
|
// No target spec available. Use the default one, useful on most systems
|
|
// with a regular OS.
|
|
spec := TargetSpec{
|
|
Triple: triple,
|
|
GOOS: goos,
|
|
GOARCH: goarch,
|
|
BuildTags: []string{goos, goarch},
|
|
GC: "precise",
|
|
Scheduler: "tasks",
|
|
Linker: "cc",
|
|
DefaultStackSize: 1024 * 64, // 64kB
|
|
GDB: []string{"gdb"},
|
|
PortReset: "false",
|
|
}
|
|
switch goarch {
|
|
case "386":
|
|
spec.CPU = "pentium4"
|
|
spec.Features = "+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
|
|
case "amd64":
|
|
spec.CPU = "x86-64"
|
|
spec.Features = "+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
|
|
case "arm":
|
|
spec.CPU = "generic"
|
|
spec.CFlags = append(spec.CFlags, "-fno-unwind-tables", "-fno-asynchronous-unwind-tables")
|
|
switch strings.Split(triple, "-")[0] {
|
|
case "armv5":
|
|
spec.Features = "+armv5t,+strict-align,-aes,-bf16,-d32,-dotprod,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-mve.fp,-neon,-sha2,-thumb-mode,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
|
|
case "armv6":
|
|
spec.Features = "+armv6,+dsp,+fp64,+strict-align,+vfp2,+vfp2sp,-aes,-d32,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-neon,-sha2,-thumb-mode,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
|
|
case "armv7":
|
|
spec.Features = "+armv7-a,+d32,+dsp,+fp64,+neon,+vfp2,+vfp2sp,+vfp3,+vfp3d16,+vfp3d16sp,+vfp3sp,-aes,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-sha2,-thumb-mode,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
|
|
}
|
|
case "arm64":
|
|
spec.CPU = "generic"
|
|
spec.Features = "+neon"
|
|
}
|
|
if goos == "darwin" {
|
|
spec.Linker = "ld.lld"
|
|
spec.Libc = "darwin-libSystem"
|
|
arch := strings.Split(triple, "-")[0]
|
|
platformVersion := strings.TrimPrefix(strings.Split(triple, "-")[2], "macosx")
|
|
spec.LDFlags = append(spec.LDFlags,
|
|
"-flavor", "darwin",
|
|
"-dead_strip",
|
|
"-arch", arch,
|
|
"-platform_version", "macos", platformVersion, platformVersion,
|
|
)
|
|
} else if goos == "linux" {
|
|
spec.Linker = "ld.lld"
|
|
spec.RTLib = "compiler-rt"
|
|
spec.Libc = "musl"
|
|
spec.LDFlags = append(spec.LDFlags, "--gc-sections")
|
|
} else if goos == "windows" {
|
|
spec.Linker = "ld.lld"
|
|
spec.Libc = "mingw-w64"
|
|
// Note: using a medium code model, low image base and no ASLR
|
|
// because Go doesn't really need those features. ASLR patches
|
|
// around issues for unsafe languages like C/C++ that are not
|
|
// normally present in Go (without explicitly opting in).
|
|
// For more discussion:
|
|
// https://groups.google.com/g/Golang-nuts/c/Jd9tlNc6jUE/m/Zo-7zIP_m3MJ?pli=1
|
|
spec.LDFlags = append(spec.LDFlags,
|
|
"-m", "i386pep",
|
|
"-Bdynamic",
|
|
"--image-base", "0x400000",
|
|
"--gc-sections",
|
|
"--no-insert-timestamp",
|
|
"--no-dynamicbase",
|
|
)
|
|
} else {
|
|
spec.LDFlags = append(spec.LDFlags, "-no-pie", "-Wl,--gc-sections") // WARNING: clang < 5.0 requires -nopie
|
|
}
|
|
if goarch != "wasm" {
|
|
suffix := ""
|
|
if goos == "windows" {
|
|
// Windows uses a different calling convention from other operating
|
|
// systems so we need separate assembly files.
|
|
suffix = "_windows"
|
|
}
|
|
spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/asm_"+goarch+suffix+".S")
|
|
spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+suffix+".S")
|
|
}
|
|
if goarch != runtime.GOARCH {
|
|
// Some educated guesses as to how to invoke helper programs.
|
|
spec.GDB = []string{"gdb-multiarch"}
|
|
if goos == "linux" {
|
|
switch goarch {
|
|
case "386":
|
|
// amd64 can _usually_ run 32-bit programs, so skip the emulator in that case.
|
|
if runtime.GOARCH != "amd64" {
|
|
spec.Emulator = "qemu-i386 {}"
|
|
}
|
|
case "amd64":
|
|
spec.Emulator = "qemu-x86_64 {}"
|
|
case "arm":
|
|
spec.Emulator = "qemu-arm {}"
|
|
case "arm64":
|
|
spec.Emulator = "qemu-aarch64 {}"
|
|
}
|
|
}
|
|
}
|
|
if goos != runtime.GOOS {
|
|
if goos == "windows" {
|
|
spec.Emulator = "wine {}"
|
|
}
|
|
}
|
|
return &spec, nil
|
|
}
|
|
|
|
// LookupGDB looks up a gdb executable.
|
|
func (spec *TargetSpec) LookupGDB() (string, error) {
|
|
if len(spec.GDB) == 0 {
|
|
return "", errors.New("gdb not configured in the target specification")
|
|
}
|
|
for _, d := range spec.GDB {
|
|
_, err := exec.LookPath(d)
|
|
if err == nil {
|
|
return d, nil
|
|
}
|
|
}
|
|
return "", errors.New("no gdb found configured in the target specification (" + strings.Join(spec.GDB, ", ") + ")")
|
|
}
|