9cad8bd0c8
On Debian, all LLVM commands have a version suffix (clang-8, ld.lld-8, wasm-ld-8, etc.). However. Most other distributions only provide a version prefix for Clang and not for all the other commands. This commit fixes the issue by trying the command with the version suffix first and falling back to one without if needed.
294 строки
6,6 КиБ
Go
294 строки
6,6 КиБ
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/blakesmith/ar"
|
|
)
|
|
|
|
// These are the GENERIC_SOURCES according to CMakeList.txt.
|
|
var genericBuiltins = []string{
|
|
"absvdi2.c",
|
|
"absvsi2.c",
|
|
"absvti2.c",
|
|
"adddf3.c",
|
|
"addsf3.c",
|
|
"addtf3.c",
|
|
"addvdi3.c",
|
|
"addvsi3.c",
|
|
"addvti3.c",
|
|
"apple_versioning.c",
|
|
"ashldi3.c",
|
|
"ashlti3.c",
|
|
"ashrdi3.c",
|
|
"ashrti3.c",
|
|
"bswapdi2.c",
|
|
"bswapsi2.c",
|
|
"clzdi2.c",
|
|
"clzsi2.c",
|
|
"clzti2.c",
|
|
"cmpdi2.c",
|
|
"cmpti2.c",
|
|
"comparedf2.c",
|
|
"comparesf2.c",
|
|
"ctzdi2.c",
|
|
"ctzsi2.c",
|
|
"ctzti2.c",
|
|
"divdc3.c",
|
|
"divdf3.c",
|
|
"divdi3.c",
|
|
"divmoddi4.c",
|
|
"divmodsi4.c",
|
|
"divsc3.c",
|
|
"divsf3.c",
|
|
"divsi3.c",
|
|
"divtc3.c",
|
|
"divti3.c",
|
|
"divtf3.c",
|
|
"extendsfdf2.c",
|
|
"extendhfsf2.c",
|
|
"ffsdi2.c",
|
|
"ffssi2.c",
|
|
"ffsti2.c",
|
|
"fixdfdi.c",
|
|
"fixdfsi.c",
|
|
"fixdfti.c",
|
|
"fixsfdi.c",
|
|
"fixsfsi.c",
|
|
"fixsfti.c",
|
|
"fixunsdfdi.c",
|
|
"fixunsdfsi.c",
|
|
"fixunsdfti.c",
|
|
"fixunssfdi.c",
|
|
"fixunssfsi.c",
|
|
"fixunssfti.c",
|
|
"floatdidf.c",
|
|
"floatdisf.c",
|
|
"floatsidf.c",
|
|
"floatsisf.c",
|
|
"floattidf.c",
|
|
"floattisf.c",
|
|
"floatundidf.c",
|
|
"floatundisf.c",
|
|
"floatunsidf.c",
|
|
"floatunsisf.c",
|
|
"floatuntidf.c",
|
|
"floatuntisf.c",
|
|
//"int_util.c",
|
|
"lshrdi3.c",
|
|
"lshrti3.c",
|
|
"moddi3.c",
|
|
"modsi3.c",
|
|
"modti3.c",
|
|
"muldc3.c",
|
|
"muldf3.c",
|
|
"muldi3.c",
|
|
"mulodi4.c",
|
|
"mulosi4.c",
|
|
"muloti4.c",
|
|
"mulsc3.c",
|
|
"mulsf3.c",
|
|
"multi3.c",
|
|
"multf3.c",
|
|
"mulvdi3.c",
|
|
"mulvsi3.c",
|
|
"mulvti3.c",
|
|
"negdf2.c",
|
|
"negdi2.c",
|
|
"negsf2.c",
|
|
"negti2.c",
|
|
"negvdi2.c",
|
|
"negvsi2.c",
|
|
"negvti2.c",
|
|
"os_version_check.c",
|
|
"paritydi2.c",
|
|
"paritysi2.c",
|
|
"parityti2.c",
|
|
"popcountdi2.c",
|
|
"popcountsi2.c",
|
|
"popcountti2.c",
|
|
"powidf2.c",
|
|
"powisf2.c",
|
|
"powitf2.c",
|
|
"subdf3.c",
|
|
"subsf3.c",
|
|
"subvdi3.c",
|
|
"subvsi3.c",
|
|
"subvti3.c",
|
|
"subtf3.c",
|
|
"trampoline_setup.c",
|
|
"truncdfhf2.c",
|
|
"truncdfsf2.c",
|
|
"truncsfhf2.c",
|
|
"ucmpdi2.c",
|
|
"ucmpti2.c",
|
|
"udivdi3.c",
|
|
"udivmoddi4.c",
|
|
"udivmodsi4.c",
|
|
"udivmodti4.c",
|
|
"udivsi3.c",
|
|
"udivti3.c",
|
|
"umoddi3.c",
|
|
"umodsi3.c",
|
|
"umodti3.c",
|
|
}
|
|
|
|
var aeabiBuiltins = []string{
|
|
"arm/aeabi_cdcmp.S",
|
|
"arm/aeabi_cdcmpeq_check_nan.c",
|
|
"arm/aeabi_cfcmp.S",
|
|
"arm/aeabi_cfcmpeq_check_nan.c",
|
|
"arm/aeabi_dcmp.S",
|
|
"arm/aeabi_div0.c",
|
|
"arm/aeabi_drsub.c",
|
|
"arm/aeabi_fcmp.S",
|
|
"arm/aeabi_frsub.c",
|
|
"arm/aeabi_idivmod.S",
|
|
"arm/aeabi_ldivmod.S",
|
|
"arm/aeabi_memcmp.S",
|
|
"arm/aeabi_memcpy.S",
|
|
"arm/aeabi_memmove.S",
|
|
"arm/aeabi_memset.S",
|
|
"arm/aeabi_uidivmod.S",
|
|
"arm/aeabi_uldivmod.S",
|
|
}
|
|
|
|
func builtinFiles(target string) []string {
|
|
builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
|
|
if strings.HasPrefix(target, "arm") {
|
|
builtins = append(builtins, aeabiBuiltins...)
|
|
}
|
|
return builtins
|
|
}
|
|
|
|
// builtinsDir returns the directory where the sources for compiler-rt are kept.
|
|
func builtinsDir() string {
|
|
return filepath.Join(sourceDir(), "lib", "compiler-rt", "lib", "builtins")
|
|
}
|
|
|
|
// Get the builtins archive, possibly generating it as needed.
|
|
func loadBuiltins(target string) (path string, err error) {
|
|
// Try to load a precompiled compiler-rt library.
|
|
precompiledPath := filepath.Join(sourceDir(), "pkg", target, "compiler-rt.a")
|
|
if _, err := os.Stat(precompiledPath); err == nil {
|
|
// Found a precompiled compiler-rt for this OS/architecture. Return the
|
|
// path directly.
|
|
return precompiledPath, nil
|
|
}
|
|
|
|
outfile := "librt-" + target + ".a"
|
|
builtinsDir := builtinsDir()
|
|
|
|
builtins := builtinFiles(target)
|
|
srcs := make([]string, len(builtins))
|
|
for i, name := range builtins {
|
|
srcs[i] = filepath.Join(builtinsDir, name)
|
|
}
|
|
|
|
if path, err := cacheLoad(outfile, commands["clang"][0], srcs); path != "" || err != nil {
|
|
return path, err
|
|
}
|
|
|
|
var cachepath string
|
|
err = compileBuiltins(target, func(path string) error {
|
|
path, err := cacheStore(path, outfile, commands["clang"][0], srcs)
|
|
cachepath = path
|
|
return err
|
|
})
|
|
return cachepath, err
|
|
}
|
|
|
|
// compileBuiltins compiles builtins from compiler-rt into a static library.
|
|
// When it succeeds, it will call the callback with the resulting path. The path
|
|
// will be removed after callback returns. If callback returns an error, this is
|
|
// passed through to the return value of this function.
|
|
func compileBuiltins(target string, callback func(path string) error) error {
|
|
builtinsDir := builtinsDir()
|
|
|
|
builtins := builtinFiles(target)
|
|
srcs := make([]string, len(builtins))
|
|
for i, name := range builtins {
|
|
srcs[i] = filepath.Join(builtinsDir, name)
|
|
}
|
|
|
|
dirPrefix := "tinygo-builtins"
|
|
remapDir := filepath.Join(os.TempDir(), dirPrefix)
|
|
dir, err := ioutil.TempDir(os.TempDir(), dirPrefix)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer os.RemoveAll(dir)
|
|
|
|
// Compile all builtins.
|
|
// TODO: use builtins optimized for a given target if available.
|
|
objs := make([]string, 0, len(builtins))
|
|
for _, name := range builtins {
|
|
objname := name
|
|
if strings.LastIndexByte(objname, '/') >= 0 {
|
|
objname = objname[strings.LastIndexByte(objname, '/'):]
|
|
}
|
|
objpath := filepath.Join(dir, objname+".o")
|
|
objs = append(objs, objpath)
|
|
srcpath := filepath.Join(builtinsDir, name)
|
|
// Note: -fdebug-prefix-map is necessary to make the output archive
|
|
// reproducible. Otherwise the temporary directory is stored in the
|
|
// archive itself, which varies each run.
|
|
err := execCommand(commands["clang"], "-c", "-Oz", "-g", "-Werror", "-Wall", "-std=c11", "-fshort-enums", "-nostdlibinc", "-ffunction-sections", "-fdata-sections", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir, "-o", objpath, srcpath)
|
|
if err != nil {
|
|
return &commandError{"failed to build", srcpath, err}
|
|
}
|
|
}
|
|
|
|
// Put all builtins in an archive to link as a static library.
|
|
// Note: this does not create a symbol index, but ld.lld doesn't seem to
|
|
// care.
|
|
arpath := filepath.Join(dir, "librt.a")
|
|
arfile, err := os.Create(arpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer arfile.Close()
|
|
arwriter := ar.NewWriter(arfile)
|
|
err = arwriter.WriteGlobalHeader()
|
|
if err != nil {
|
|
return &os.PathError{"write ar header", arpath, err}
|
|
}
|
|
for _, objpath := range objs {
|
|
name := filepath.Base(objpath)
|
|
objfile, err := os.Open(objpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer objfile.Close()
|
|
st, err := objfile.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
arwriter.WriteHeader(&ar.Header{
|
|
Name: name,
|
|
ModTime: time.Unix(0, 0),
|
|
Uid: 0,
|
|
Gid: 0,
|
|
Mode: 0644,
|
|
Size: st.Size(),
|
|
})
|
|
n, err := io.Copy(arwriter, objfile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if n != st.Size() {
|
|
return errors.New("file modified during ar creation: " + arpath)
|
|
}
|
|
}
|
|
|
|
// Give the caller the resulting file. The callback must copy the file,
|
|
// because after it returns the temporary directory will be removed.
|
|
arfile.Close()
|
|
return callback(arpath)
|
|
}
|