mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-21 22:34:05 +00:00
Delete the mk folder
This commit deletes the old build system located in the `mk` folder as it's now been obsoleted for two cycles and is replaced by rustbuild.
This commit is contained in:
Alex Crichton
parent
4711ac314c
commit
9ab8090bd4
297
Makefile.in
297
Makefile.in
@ -1,297 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# <help> \(^o^)/
|
||||
#
|
||||
# Greetings, adventurer! The Rust Build System is at your service.
|
||||
#
|
||||
# Whether you want a genuine copy of `rustc`, access to the latest and
|
||||
# most authoritative Rust documentation, or even to investigate the
|
||||
# most intimate workings of the compiler itself, you've come to the
|
||||
# right place. Let's see what's on the menu.
|
||||
#
|
||||
# Please note that most of these options only work if configure was
|
||||
# run with --disable-rustbuild. For documentation on the new build
|
||||
# system, see CONTRIBUTING.md.
|
||||
#
|
||||
# First, start with one of these build targets:
|
||||
#
|
||||
# * all - The default. Build a complete, bootstrapped compiler.
|
||||
# `rustc` will be in `${target-triple}/stage2/bin/`. Run it
|
||||
# directly from the build directory if you like. This also
|
||||
# comes with docs in `doc/`.
|
||||
#
|
||||
# * check - Run the complete test suite
|
||||
#
|
||||
# * clean - Clean the build repository. It is advised to run this
|
||||
# command if you want to build Rust again, after an update
|
||||
# of the git repository.
|
||||
#
|
||||
# * install - Install Rust. Note that installation is not necessary
|
||||
# to use the compiler.
|
||||
#
|
||||
# * uninstall - Uninstall the binaries
|
||||
#
|
||||
# For tips on working with The Rust Build System, just:
|
||||
#
|
||||
# run `make tips`
|
||||
#
|
||||
# Otherwise
|
||||
#
|
||||
# run `make`
|
||||
#
|
||||
# </help>
|
||||
#
|
||||
# <tips>
|
||||
#
|
||||
# # The Rust Build System Tip Line
|
||||
#
|
||||
# There are a bazillion different targets you might want to build. Here
|
||||
# are a few ideas.
|
||||
#
|
||||
# * docs - Build gobs of HTML documentation and put it into `doc/`
|
||||
# * check-$(crate) - Test a crate, e.g. `check-std`
|
||||
# * check-ref - Run the language reference tests
|
||||
# * check-docs - Test the documentation examples
|
||||
# * check-stage$(stage)-$(crate) - Test a crate in a specific stage
|
||||
# * check-stage$(stage)-{rpass,rfail,cfail,rmake,...} - Run tests in src/test/
|
||||
# * check-stage1-T-$(target)-H-$(host) - Run cross-compiled-tests
|
||||
# * tidy - Basic style check, show highest rustc error code and
|
||||
# the status of language and lib features
|
||||
# * rustc-stage$(stage) - Only build up to a specific stage
|
||||
# * $host/stage1/bin/rustc - Only build stage1 rustc, not libstd. For further
|
||||
# information see "Rust recipes for build system success" below.
|
||||
#
|
||||
# Then mix in some of these environment variables to harness the
|
||||
# ultimate power of The Rust Build System.
|
||||
#
|
||||
# * `VERBOSE=1` - Print all commands. Use this to see what's going on.
|
||||
# * `RUSTFLAGS=...` - Add compiler flags to all `rustc` invocations
|
||||
# * `JEMALLOC_FLAGS=...` - Pass flags to jemalloc's configure script
|
||||
#
|
||||
# * `TESTNAME=...` - Specify the name of tests to run
|
||||
# * `CHECK_IGNORED=1` - Run normally-ignored tests
|
||||
# * `PLEASE_BENCH=1` - Run crate benchmarks (enable `--bench` flag)
|
||||
#
|
||||
# * `CFG_ENABLE_VALGRIND=1` - Run tests under valgrind
|
||||
# * `VALGRIND_COMPILE=1` - Run the compiler itself under valgrind
|
||||
# (requires `CFG_ENABLE_VALGRIND`)
|
||||
#
|
||||
# * `NO_REBUILD=1` - Don't rebootstrap when testing std
|
||||
# (and possibly other crates)
|
||||
# * `NO_MKFILE_DEPS=1` - Don't rebuild for modified .mk files
|
||||
#
|
||||
# * `SAVE_TEMPS=1` - Use `--save-temps` flag on all `rustc` invocations
|
||||
# * `ASM_COMMENTS=1` - Use `-Z asm-comments`
|
||||
# * `TIME_PASSES=1` - Use `-Z time-passes`
|
||||
# * `TIME_LLVM_PASSES=1` - Use `-Z time-llvm-passes`
|
||||
# * `TRACE=1` - Use `-Z trace`
|
||||
#
|
||||
# # Rust recipes for build system success
|
||||
#
|
||||
# // Modifying libstd? Use this command to run unit tests just on your change
|
||||
# make check-stage1-std NO_REBUILD=1 NO_BENCH=1
|
||||
#
|
||||
# // Modifying just rustc?
|
||||
# // Compile rustc+libstd once
|
||||
# make rustc-stage1
|
||||
# // From now on use this command to rebuild just rustc and reuse the previously built libstd
|
||||
# // $host is a target triple, eg. x86_64-unknown-linux-gnu
|
||||
# // The resulting binary is located at $host/stage1/bin/rustc.
|
||||
# // If there are any issues with libstd recompile it with the command above.
|
||||
# make $host/stage1/bin/rustc
|
||||
#
|
||||
# // Added a run-pass test? Use this to test running your test
|
||||
# make check-stage1-rpass TESTNAME=my-shiny-new-test
|
||||
#
|
||||
# // Having trouble figuring out which test is failing? Turn off parallel tests
|
||||
# make check-stage1-std RUST_TEST_THREADS=1
|
||||
#
|
||||
# // To make debug!() and other logging calls visible, reconfigure:
|
||||
# ./configure --enable-debug-assertions
|
||||
# make ....
|
||||
#
|
||||
# If you really feel like getting your hands dirty, then:
|
||||
#
|
||||
# run `make nitty-gritty`
|
||||
#
|
||||
# # Make command examples
|
||||
#
|
||||
# ## Docs linked commands
|
||||
#
|
||||
# * make check-stage1-rustdocck: Builds rustdoc. It has the advantage to compile
|
||||
# quite quickly since we're only using stage1
|
||||
# executables.
|
||||
# * make doc/error-index.md: Gets all doc blocks from doc comments and error
|
||||
# explanations to put them in a markdown file. You
|
||||
# can then test them by running
|
||||
# "rustdoc --test error-index.md".
|
||||
#
|
||||
# And of course, the wonderfully useful 'make tidy'! Always run it before opening a pull request to rust!
|
||||
#
|
||||
# </tips>
|
||||
#
|
||||
# <nitty-gritty>
|
||||
#
|
||||
# # The Rust Build System
|
||||
#
|
||||
# Gosh I wish there was something useful here (TODO).
|
||||
#
|
||||
# # An (old) explanation of how the build is structured:
|
||||
#
|
||||
# *Note: Hey, like, this is probably inaccurate, and is definitely
|
||||
# an outdated and insufficient explanation of the remarkable
|
||||
# Rust Build System.*
|
||||
#
|
||||
# There are multiple build stages (0-3) needed to verify that the
|
||||
# compiler is properly self-hosting. Each stage is divided between
|
||||
# 'host' artifacts and 'target' artifacts, where the stageN host
|
||||
# compiler builds artifacts for 1 or more stageN target architectures.
|
||||
# Once the stageN target compiler has been built for the host
|
||||
# architecture it is promoted (copied) to a stageN+1 host artifact.
|
||||
#
|
||||
# The stage3 host compiler is a compiler that successfully builds
|
||||
# itself and should (in theory) be bitwise identical to the stage2
|
||||
# host compiler. The process is bootstrapped using a stage0 host
|
||||
# compiler downloaded from a previous snapshot.
|
||||
#
|
||||
# At no time should stageN artifacts be interacting with artifacts
|
||||
# from other stages. For consistency, we use the 'promotion' logic
|
||||
# for all artifacts, even those that don't make sense on non-host
|
||||
# architectures.
|
||||
#
|
||||
# The directory layout for a stage is intended to match the layout
|
||||
# of the installed compiler, and looks like the following:
|
||||
#
|
||||
# stageN - this is the system root, corresponding to, e.g. /usr
|
||||
# bin - binaries compiled for the host
|
||||
# lib - libraries used by the host compiler
|
||||
# rustlib - rustc's own place to organize libraries
|
||||
# $(target) - target-specific artifacts
|
||||
# bin - binaries for target architectures
|
||||
# lib - libraries for target architectures
|
||||
#
|
||||
# A note about host libraries:
|
||||
#
|
||||
# The only libraries that get promoted to stageN/lib are those needed
|
||||
# by rustc. In general, rust programs, even those compiled for the
|
||||
# host architecture will use libraries from the target
|
||||
# directories. This gives rust some freedom to experiment with how
|
||||
# libraries are managed and versioned without polluting the common
|
||||
# areas of the filesystem.
|
||||
#
|
||||
# General rust binaries may still live in the host bin directory; they
|
||||
# will just link against the libraries in the target lib directory.
|
||||
#
|
||||
# Admittedly this is a little convoluted.
|
||||
#
|
||||
# If you find yourself working on the make infrastructure itself, and trying to
|
||||
# find the value of a given variable after expansion, you can use:
|
||||
#
|
||||
# make print-VARIABLE_NAME
|
||||
#
|
||||
# To extract it
|
||||
#
|
||||
# </nitty-gritty>
|
||||
#
|
||||
|
||||
######################################################################
|
||||
# Primary rules
|
||||
######################################################################
|
||||
|
||||
# Issue #9531: If you change the order of any of the following (or add
|
||||
# new definitions), make sure definitions always precede their uses,
|
||||
# especially for the dependency lists of recipes.
|
||||
|
||||
# First, load the variables exported by the configure script
|
||||
include config.mk
|
||||
|
||||
# Just a few macros used everywhere
|
||||
include $(CFG_SRC_DIR)mk/util.mk
|
||||
# Reconfiguring when the makefiles or submodules change
|
||||
include $(CFG_SRC_DIR)mk/reconfig.mk
|
||||
# All crates and their dependencies
|
||||
include $(CFG_SRC_DIR)mk/crates.mk
|
||||
# Various bits of setup, common macros, and top-level rules
|
||||
include $(CFG_SRC_DIR)mk/main.mk
|
||||
# C and assembly components that are not LLVM
|
||||
include $(CFG_SRC_DIR)mk/rt.mk
|
||||
# Rules for crates in the target directories
|
||||
include $(CFG_SRC_DIR)mk/target.mk
|
||||
# Rules for crates in the host directories
|
||||
include $(CFG_SRC_DIR)mk/host.mk
|
||||
# Special rules for bootstrapping stage0
|
||||
include $(CFG_SRC_DIR)mk/stage0.mk
|
||||
# Rust-specific LLVM extensions
|
||||
include $(CFG_SRC_DIR)mk/rustllvm.mk
|
||||
# Documentation
|
||||
include $(CFG_SRC_DIR)mk/docs.mk
|
||||
# LLVM
|
||||
include $(CFG_SRC_DIR)mk/llvm.mk
|
||||
# Rules for installing debugger scripts
|
||||
include $(CFG_SRC_DIR)mk/debuggers.mk
|
||||
|
||||
######################################################################
|
||||
# Secondary makefiles, conditionalized for speed
|
||||
######################################################################
|
||||
|
||||
# The test suite
|
||||
ifneq ($(strip $(findstring check,$(MAKECMDGOALS)) \
|
||||
$(findstring test,$(MAKECMDGOALS)) \
|
||||
$(findstring tidy,$(MAKECMDGOALS))),)
|
||||
CFG_INFO := $(info cfg: including test rules)
|
||||
include $(CFG_SRC_DIR)mk/tests.mk
|
||||
include $(CFG_SRC_DIR)mk/grammar.mk
|
||||
endif
|
||||
|
||||
# Copy all the distributables to another directory for binary install
|
||||
ifneq ($(strip $(findstring prepare,$(MAKECMDGOALS)) \
|
||||
$(findstring dist,$(MAKECMDGOALS)) \
|
||||
$(findstring install,$(MAKECMDGOALS))),)
|
||||
CFG_INFO := $(info cfg: including prepare rules)
|
||||
include $(CFG_SRC_DIR)mk/prepare.mk
|
||||
endif
|
||||
|
||||
# Source and binary distribution artifacts
|
||||
ifneq ($(strip $(findstring dist,$(MAKECMDGOALS)) \
|
||||
$(findstring install,$(MAKECMDGOALS)) \
|
||||
$(findstring clean,$(MAKECMDGOALS))),)
|
||||
CFG_INFO := $(info cfg: including dist rules)
|
||||
include $(CFG_SRC_DIR)mk/dist.mk
|
||||
endif
|
||||
|
||||
# (Unix) Installation from the build directory
|
||||
ifneq ($(findstring install,$(MAKECMDGOALS)),)
|
||||
CFG_INFO := $(info cfg: including install rules)
|
||||
include $(CFG_SRC_DIR)mk/install.mk
|
||||
endif
|
||||
|
||||
# Cleaning
|
||||
ifneq ($(findstring clean,$(MAKECMDGOALS)),)
|
||||
CFG_INFO := $(info cfg: including clean rules)
|
||||
include $(CFG_SRC_DIR)mk/clean.mk
|
||||
endif
|
||||
|
||||
# CTAGS building
|
||||
ifneq ($(strip $(findstring TAGS.emacs,$(MAKECMDGOALS)) \
|
||||
$(findstring TAGS.vi,$(MAKECMDGOALS)) \
|
||||
$(findstring TAGS.rustc.emacs,$(MAKECMDGOALS)) \
|
||||
$(findstring TAGS.rustc.vi,$(MAKECMDGOALS))),)
|
||||
CFG_INFO := $(info cfg: including ctags rules)
|
||||
include $(CFG_SRC_DIR)mk/ctags.mk
|
||||
endif
|
||||
|
||||
.DEFAULT:
|
||||
@echo
|
||||
@echo "======================================================"
|
||||
@echo "== If you need help, run 'make help' or 'make tips' =="
|
||||
@echo "======================================================"
|
||||
@echo
|
||||
exit 1
|
||||
@ -1,33 +0,0 @@
|
||||
# aarch64-apple-ios configuration
|
||||
CFG_SDK_NAME_aarch64-apple-ios := iphoneos
|
||||
CFG_SDK_ARCHS_aarch64-apple-ios := arm64
|
||||
ifneq ($(findstring darwin,$(CFG_OSTYPE)),)
|
||||
CFG_IOS_SDK_aarch64-apple-ios := $(shell xcrun --show-sdk-path -sdk iphoneos 2>/dev/null)
|
||||
CFG_IOS_SDK_FLAGS_aarch64-apple-ios := -target aarch64-apple-darwin -isysroot $(CFG_IOS_SDK_aarch64-apple-ios) -mios-version-min=7.0 -arch arm64
|
||||
CC_aarch64-apple-ios = $(shell xcrun -find -sdk iphoneos clang)
|
||||
LINK_aarch64-apple-ios = $(shell xcrun -find -sdk iphoneos clang)
|
||||
CXX_aarch64-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
CPP_aarch64-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
AR_aarch64-apple-ios = $(shell xcrun -find -sdk iphoneos ar)
|
||||
endif
|
||||
CFG_LIB_NAME_aarch64-apple-ios = lib$(1).a
|
||||
CFG_LIB_GLOB_aarch64-apple-ios = lib$(1)-*.a
|
||||
CFG_INSTALL_ONLY_RLIB_aarch64-apple-ios = 1
|
||||
CFG_STATIC_LIB_NAME_aarch64-apple-ios=lib$(1).a
|
||||
CFG_LIB_DSYM_GLOB_aarch64-apple-ios = lib$(1)-*.a.dSYM
|
||||
CFG_CFLAGS_aarch64-apple-ios := $(CFG_IOS_SDK_FLAGS_aarch64-apple-ios)
|
||||
CFG_JEMALLOC_CFLAGS_aarch64-apple-ios := $(CFG_IOS_SDK_FLAGS_aarch64-apple-ios)
|
||||
CFG_GCCISH_CFLAGS_aarch64-apple-ios := -fPIC $(CFG_IOS_SDK_FLAGS_aarch64-apple-ios)
|
||||
CFG_GCCISH_CXXFLAGS_aarch64-apple-ios := -fno-rtti $(CFG_IOS_SDK_FLAGS_aarch64-apple-ios) -I$(CFG_IOS_SDK_aarch64-apple-ios)/usr/include/c++/4.2.1
|
||||
CFG_GCCISH_LINK_FLAGS_aarch64-apple-ios := -lpthread -syslibroot $(CFG_IOS_SDK_aarch64-apple-ios) -Wl,-no_compact_unwind
|
||||
CFG_GCCISH_DEF_FLAG_aarch64-apple-ios := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_aarch64-apple-ios := -mattr=+neon,+cyclone,+fp-armv8
|
||||
CFG_INSTALL_NAME_aarch64-apple-ios = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_LIBUV_LINK_FLAGS_aarch64-apple-ios =
|
||||
CFG_EXE_SUFFIX_aarch64-apple-ios :=
|
||||
CFG_WINDOWSY_aarch64-apple-ios :=
|
||||
CFG_UNIXY_aarch64-apple-ios := 1
|
||||
CFG_LDPATH_aarch64-apple-ios :=
|
||||
CFG_RUN_aarch64-apple-ios = $(2)
|
||||
CFG_RUN_TARG_aarch64-apple-ios = $(call CFG_RUN_aarch64-apple-ios,,$(2))
|
||||
CFG_GNU_TRIPLE_aarch64-apple-ios := aarch64-apple-ios
|
||||
@ -1,26 +0,0 @@
|
||||
# aarch64-linux-android configuration
|
||||
# CROSS_PREFIX_aarch64-linux-android-
|
||||
CC_aarch64-linux-android=$(CFG_AARCH64_LINUX_ANDROID_NDK)/bin/aarch64-linux-android-gcc
|
||||
CXX_aarch64-linux-android=$(CFG_AARCH64_LINUX_ANDROID_NDK)/bin/aarch64-linux-android-g++
|
||||
CPP_aarch64-linux-android=$(CFG_AARCH64_LINUX_ANDROID_NDK)/bin/aarch64-linux-android-gcc -E
|
||||
AR_aarch64-linux-android=$(CFG_AARCH64_LINUX_ANDROID_NDK)/bin/aarch64-linux-android-ar
|
||||
CFG_LIB_NAME_aarch64-linux-android=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_aarch64-linux-android=lib$(1).a
|
||||
CFG_LIB_GLOB_aarch64-linux-android=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_aarch64-linux-android=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_aarch64-linux-android := -D__aarch64__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_aarch64-linux-android := -Wall -g -fPIC -D__aarch64__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_aarch64-linux-android := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_aarch64-linux-android := -shared -fPIC -ldl -g -lm -lsupc++
|
||||
CFG_GCCISH_DEF_FLAG_aarch64-linux-android := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_aarch64-linux-android :=
|
||||
CFG_INSTALL_NAME_aarch64-linux-android =
|
||||
CFG_EXE_SUFFIX_aarch64-linux-android :=
|
||||
CFG_WINDOWSY_aarch64-linux-android :=
|
||||
CFG_UNIXY_aarch64-linux-android := 1
|
||||
CFG_LDPATH_aarch64-linux-android :=
|
||||
CFG_RUN_aarch64-linux-android=
|
||||
CFG_RUN_TARG_aarch64-linux-android=
|
||||
RUSTC_FLAGS_aarch64-linux-android :=
|
||||
RUSTC_CROSS_FLAGS_aarch64-linux-android :=
|
||||
CFG_GNU_TRIPLE_aarch64-linux-android := aarch64-linux-android
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1,26 +0,0 @@
|
||||
# aarch64-unknown-linux-gnu configuration
|
||||
CROSS_PREFIX_aarch64-unknown-linux-gnu=aarch64-linux-gnu-
|
||||
CC_aarch64-unknown-linux-gnu=gcc
|
||||
CXX_aarch64-unknown-linux-gnu=g++
|
||||
CPP_aarch64-unknown-linux-gnu=gcc -E
|
||||
AR_aarch64-unknown-linux-gnu=ar
|
||||
CFG_LIB_NAME_aarch64-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_aarch64-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_aarch64-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_aarch64-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_aarch64-unknown-linux-gnu := -D__aarch64__ $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_aarch64-unknown-linux-gnu := -Wall -g -fPIC -D__aarch64__ $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_aarch64-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_aarch64-unknown-linux-gnu := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_aarch64-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_aarch64-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_aarch64-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_aarch64-unknown-linux-gnu :=
|
||||
CFG_WINDOWSY_aarch64-unknown-linux-gnu :=
|
||||
CFG_UNIXY_aarch64-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_aarch64-unknown-linux-gnu :=
|
||||
CFG_RUN_aarch64-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_aarch64-unknown-linux-gnu=$(call CFG_RUN_aarch64-unknown-linux-gnu,,$(2))
|
||||
RUSTC_FLAGS_aarch64-unknown-linux-gnu :=
|
||||
RUSTC_CROSS_FLAGS_aarch64-unknown-linux-gnu :=
|
||||
CFG_GNU_TRIPLE_aarch64-unknown-linux-gnu := aarch64-unknown-linux-gnu
|
||||
@ -1,25 +0,0 @@
|
||||
# arm-linux-androideabi configuration
|
||||
CC_arm-linux-androideabi=$(CFG_ARM_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-gcc
|
||||
CXX_arm-linux-androideabi=$(CFG_ARM_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-g++
|
||||
CPP_arm-linux-androideabi=$(CFG_ARM_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-gcc -E
|
||||
AR_arm-linux-androideabi=$(CFG_ARM_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-ar
|
||||
CFG_LIB_NAME_arm-linux-androideabi=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_arm-linux-androideabi=lib$(1).a
|
||||
CFG_LIB_GLOB_arm-linux-androideabi=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_arm-linux-androideabi=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_arm-linux-androideabi := -D__arm__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_arm-linux-androideabi := -Wall -g -fPIC -D__arm__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_arm-linux-androideabi := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_arm-linux-androideabi := -shared -fPIC -ldl -g -lm -lsupc++
|
||||
CFG_GCCISH_DEF_FLAG_arm-linux-androideabi := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_arm-linux-androideabi :=
|
||||
CFG_INSTALL_NAME_arm-linux-androideabi =
|
||||
CFG_EXE_SUFFIX_arm-linux-androideabi :=
|
||||
CFG_WINDOWSY_arm-linux-androideabi :=
|
||||
CFG_UNIXY_arm-linux-androideabi := 1
|
||||
CFG_LDPATH_arm-linux-androideabi :=
|
||||
CFG_RUN_arm-linux-androideabi=
|
||||
CFG_RUN_TARG_arm-linux-androideabi=
|
||||
RUSTC_FLAGS_arm-linux-androideabi :=
|
||||
RUSTC_CROSS_FLAGS_arm-linux-androideabi :=
|
||||
CFG_GNU_TRIPLE_arm-linux-androideabi := arm-linux-androideabi
|
||||
@ -1,26 +0,0 @@
|
||||
# arm-unknown-linux-gnueabi configuration
|
||||
CROSS_PREFIX_arm-unknown-linux-gnueabi=arm-linux-gnueabi-
|
||||
CC_arm-unknown-linux-gnueabi=gcc
|
||||
CXX_arm-unknown-linux-gnueabi=g++
|
||||
CPP_arm-unknown-linux-gnueabi=gcc -E
|
||||
AR_arm-unknown-linux-gnueabi=ar
|
||||
CFG_LIB_NAME_arm-unknown-linux-gnueabi=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_arm-unknown-linux-gnueabi=lib$(1).a
|
||||
CFG_LIB_GLOB_arm-unknown-linux-gnueabi=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabi=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_arm-unknown-linux-gnueabi := -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabi := -Wall -g -fPIC -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabi := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabi := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_arm-unknown-linux-gnueabi :=
|
||||
CFG_INSTALL_NAME_arm-unknown-linux-gnueabi =
|
||||
CFG_EXE_SUFFIX_arm-unknown-linux-gnueabi :=
|
||||
CFG_WINDOWSY_arm-unknown-linux-gnueabi :=
|
||||
CFG_UNIXY_arm-unknown-linux-gnueabi := 1
|
||||
CFG_LDPATH_arm-unknown-linux-gnueabi :=
|
||||
CFG_RUN_arm-unknown-linux-gnueabi=$(2)
|
||||
CFG_RUN_TARG_arm-unknown-linux-gnueabi=$(call CFG_RUN_arm-unknown-linux-gnueabi,,$(2))
|
||||
RUSTC_FLAGS_arm-unknown-linux-gnueabi :=
|
||||
RUSTC_CROSS_FLAGS_arm-unknown-linux-gnueabi :=
|
||||
CFG_GNU_TRIPLE_arm-unknown-linux-gnueabi := arm-unknown-linux-gnueabi
|
||||
@ -1,26 +0,0 @@
|
||||
# arm-unknown-linux-gnueabihf configuration
|
||||
CROSS_PREFIX_arm-unknown-linux-gnueabihf=arm-linux-gnueabihf-
|
||||
CC_arm-unknown-linux-gnueabihf=gcc
|
||||
CXX_arm-unknown-linux-gnueabihf=g++
|
||||
CPP_arm-unknown-linux-gnueabihf=gcc -E
|
||||
AR_arm-unknown-linux-gnueabihf=ar
|
||||
CFG_LIB_NAME_arm-unknown-linux-gnueabihf=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_arm-unknown-linux-gnueabihf=lib$(1).a
|
||||
CFG_LIB_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_arm-unknown-linux-gnueabihf=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_arm-unknown-linux-gnueabihf := -D__arm__ $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CFLAGS_arm-unknown-linux-gnueabihf := -Wall -g -fPIC -D__arm__ $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CXXFLAGS_arm-unknown-linux-gnueabihf := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-gnueabihf := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_arm-unknown-linux-gnueabihf := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_arm-unknown-linux-gnueabihf :=
|
||||
CFG_INSTALL_NAME_ar,-unknown-linux-gnueabihf =
|
||||
CFG_EXE_SUFFIX_arm-unknown-linux-gnueabihf :=
|
||||
CFG_WINDOWSY_arm-unknown-linux-gnueabihf :=
|
||||
CFG_UNIXY_arm-unknown-linux-gnueabihf := 1
|
||||
CFG_LDPATH_arm-unknown-linux-gnueabihf :=
|
||||
CFG_RUN_arm-unknown-linux-gnueabihf=$(2)
|
||||
CFG_RUN_TARG_arm-unknown-linux-gnueabihf=$(call CFG_RUN_arm-unknown-linux-gnueabihf,,$(2))
|
||||
RUSTC_FLAGS_arm-unknown-linux-gnueabihf := -C target-feature=+v6,+vfp2
|
||||
RUSTC_CROSS_FLAGS_arm-unknown-linux-gnueabihf :=
|
||||
CFG_GNU_TRIPLE_arm-unknown-linux-gnueabihf := arm-unknown-linux-gnueabihf
|
||||
@ -1,26 +0,0 @@
|
||||
# arm-unknown-linux-musleabi configuration
|
||||
CROSS_PREFIX_arm-unknown-linux-musleabi=arm-linux-musleabi-
|
||||
CC_arm-unknown-linux-musleabi=gcc
|
||||
CXX_arm-unknown-linux-musleabi=g++
|
||||
CPP_arm-unknown-linux-musleabi=gcc -E
|
||||
AR_arm-unknown-linux-musleabi=ar
|
||||
CFG_LIB_NAME_arm-unknown-linux-musleabi=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_arm-unknown-linux-musleabi=lib$(1).a
|
||||
CFG_LIB_GLOB_arm-unknown-linux-musleabi=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_arm-unknown-linux-musleabi=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_arm-unknown-linux-musleabi := -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CFLAGS_arm-unknown-linux-musleabi := -Wall -g -fPIC -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv6 -marm
|
||||
CFG_GCCISH_CXXFLAGS_arm-unknown-linux-musleabi := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_arm-unknown-linux-musleabi := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_arm-unknown-linux-musleabi := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_arm-unknown-linux-musleabi :=
|
||||
CFG_INSTALL_NAME_arm-unknown-linux-musleabi =
|
||||
CFG_EXE_SUFFIX_arm-unknown-linux-musleabi :=
|
||||
CFG_WINDOWSY_arm-unknown-linux-musleabi :=
|
||||
CFG_UNIXY_arm-unknown-linux-musleabi := 1
|
||||
CFG_LDPATH_arm-unknown-linux-musleabi :=
|
||||
CFG_RUN_arm-unknown-linux-musleabi=$(2)
|
||||
CFG_RUN_TARG_arm-unknown-linux-musleabi=$(call CFG_RUN_arm-unknown-linux-musleabi,,$(2))
|
||||
RUSTC_FLAGS_arm-unknown-linux-musleabi :=
|
||||
RUSTC_CROSS_FLAGS_arm-unknown-linux-musleabi :=
|
||||
CFG_GNU_TRIPLE_arm-unknown-linux-musleabi := arm-unknown-linux-musleabi
|
||||
@ -1,3 +0,0 @@
|
||||
# This file is intentially left empty to indicate that, while this target is
|
||||
# supported, it's not supported using plain GNU Make builds. Use a --rustbuild
|
||||
# instead.
|
||||
@ -1,26 +0,0 @@
|
||||
# armv5-unknown-linux-gnueabi configuration
|
||||
CROSS_PREFIX_armv5te-unknown-linux-gnueabi=arm-linux-gnueabi-
|
||||
CC_armv5te-unknown-linux-gnueabi=gcc
|
||||
CXX_armv5te-unknown-linux-gnueabi=g++
|
||||
CPP_armv5te-unknown-linux-gnueabi=gcc -E
|
||||
AR_armv5te-unknown-linux-gnueabi=ar
|
||||
CFG_LIB_NAME_armv5te-unknown-linux-gnueabi=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_armv5te-unknown-linux-gnueabi=lib$(1).a
|
||||
CFG_LIB_GLOB_armv5te-unknown-linux-gnueabi=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_armv5te-unknown-linux-gnueabi=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_armv5te-unknown-linux-gnueabi := -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv5te -marm
|
||||
CFG_GCCISH_CFLAGS_armv5te-unknown-linux-gnueabi := -Wall -g -fPIC -D__arm__ -mfloat-abi=soft $(CFLAGS) -march=armv5te -marm
|
||||
CFG_GCCISH_CXXFLAGS_armv5te-unknown-linux-gnueabi := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_armv5te-unknown-linux-gnueabi := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_armv5te-unknown-linux-gnueabi := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_armv5te-unknown-linux-gnueabi :=
|
||||
CFG_INSTALL_NAME_ar,-unknown-linux-gnueabi =
|
||||
CFG_EXE_SUFFIX_armv5te-unknown-linux-gnueabi :=
|
||||
CFG_WINDOWSY_armv5te-unknown-linux-gnueabi :=
|
||||
CFG_UNIXY_armv5te-unknown-linux-gnueabi := 1
|
||||
CFG_LDPATH_armv5te-unknown-linux-gnueabi :=
|
||||
CFG_RUN_armv5te-unknown-linux-gnueabi=$(2)
|
||||
CFG_RUN_TARG_armv5te-unknown-linux-gnueabi=$(call CFG_RUN_armv5te-unknown-linux-gnueabi,,$(2))
|
||||
RUSTC_FLAGS_armv5te-unknown-linux-gnueabi :=
|
||||
RUSTC_CROSS_FLAGS_armv5te-unknown-linux-gnueabi :=
|
||||
CFG_GNU_TRIPLE_armv5te-unknown-linux-gnueabi := armv5te-unknown-linux-gnueabi
|
||||
@ -1,30 +0,0 @@
|
||||
# armv7-apple-ios configuration
|
||||
CFG_SDK_NAME_armv7-apple-ios := iphoneos
|
||||
CFG_SDK_ARCHS_armv7-apple-ios := armv7
|
||||
ifneq ($(findstring darwin,$(CFG_OSTYPE)),)
|
||||
CFG_IOS_SDK_armv7-apple-ios := $(shell xcrun --show-sdk-path -sdk iphoneos 2>/dev/null)
|
||||
CFG_IOS_SDK_FLAGS_armv7-apple-ios := -target armv7-apple-ios -isysroot $(CFG_IOS_SDK_armv7-apple-ios) -mios-version-min=7.0
|
||||
CC_armv7-apple-ios = $(shell xcrun -find -sdk iphoneos clang)
|
||||
CXX_armv7-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
CPP_armv7-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
AR_armv7-apple-ios = $(shell xcrun -find -sdk iphoneos ar)
|
||||
endif
|
||||
CFG_LIB_NAME_armv7-apple-ios = lib$(1).a
|
||||
CFG_LIB_GLOB_armv7-apple-ios = lib$(1)-*.a
|
||||
CFG_INSTALL_ONLY_RLIB_armv7-apple-ios = 1
|
||||
CFG_STATIC_LIB_NAME_armv7-apple-ios=lib$(1).a
|
||||
CFG_LIB_DSYM_GLOB_armv7-apple-ios = lib$(1)-*.a.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_armv7-apple-ios := -arch armv7 -mfpu=vfp3 $(CFG_IOS_SDK_FLAGS_armv7-apple-ios)
|
||||
CFG_GCCISH_CFLAGS_armv7-apple-ios := -g -fPIC $(CFG_IOS_SDK_FLAGS_armv7-apple-ios) -mfpu=vfp3 -arch armv7
|
||||
CFG_GCCISH_CXXFLAGS_armv7-apple-ios := -fno-rtti $(CFG_IOS_SDK_FLAGS_armv7-apple-ios) -I$(CFG_IOS_SDK_armv7-apple-ios)/usr/include/c++/4.2.1
|
||||
CFG_GCCISH_LINK_FLAGS_armv7-apple-ios := -lpthread -syslibroot $(CFG_IOS_SDK_armv7-apple-ios) -Wl,-no_compact_unwind
|
||||
CFG_GCCISH_DEF_FLAG_armv7-apple-ios := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_armv7-apple-ios := -mattr=+vfp3,+v7,+neon -march=arm
|
||||
CFG_INSTALL_NAME_armv7-apple-ios = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_EXE_SUFFIX_armv7-apple-ios :=
|
||||
CFG_WINDOWSY_armv7-apple-ios :=
|
||||
CFG_UNIXY_armv7-apple-ios := 1
|
||||
CFG_LDPATH_armv7-apple-ios :=
|
||||
CFG_RUN_armv7-apple-ios = $(2)
|
||||
CFG_RUN_TARG_armv7-apple-ios = $(call CFG_RUN_armv7-apple-ios,,$(2))
|
||||
CFG_GNU_TRIPLE_armv7-apple-ios := armv7-apple-ios
|
||||
@ -1,25 +0,0 @@
|
||||
# armv7-linux-androideabi configuration
|
||||
CC_armv7-linux-androideabi=$(CFG_ARMV7_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-gcc
|
||||
CXX_armv7-linux-androideabi=$(CFG_ARMV7_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-g++
|
||||
CPP_armv7-linux-androideabi=$(CFG_ARMV7_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-gcc -E
|
||||
AR_armv7-linux-androideabi=$(CFG_ARMV7_LINUX_ANDROIDEABI_NDK)/bin/arm-linux-androideabi-ar
|
||||
CFG_LIB_NAME_armv7-linux-androideabi=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_armv7-linux-androideabi=lib$(1).a
|
||||
CFG_LIB_GLOB_armv7-linux-androideabi=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_armv7-linux-androideabi=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_armv7-linux-androideabi := -D__arm__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_armv7-linux-androideabi := -Wall -g -fPIC -D__arm__ -mfloat-abi=softfp -march=armv7-a -mfpu=vfpv3-d16 -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_armv7-linux-androideabi := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_armv7-linux-androideabi := -shared -fPIC -ldl -g -lm -lsupc++
|
||||
CFG_GCCISH_DEF_FLAG_armv7-linux-androideabi := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_armv7-linux-androideabi :=
|
||||
CFG_INSTALL_NAME_armv7-linux-androideabi =
|
||||
CFG_EXE_SUFFIX_armv7-linux-androideabi :=
|
||||
CFG_WINDOWSY_armv7-linux-androideabi :=
|
||||
CFG_UNIXY_armv7-linux-androideabi := 1
|
||||
CFG_LDPATH_armv7-linux-androideabi :=
|
||||
CFG_RUN_armv7-linux-androideabi=
|
||||
CFG_RUN_TARG_armv7-linux-androideabi=
|
||||
RUSTC_FLAGS_armv7-linux-androideabi :=
|
||||
RUSTC_CROSS_FLAGS_armv7-linux-androideabi :=
|
||||
CFG_GNU_TRIPLE_armv7-linux-androideabi := arm-linux-androideabi
|
||||
@ -1,26 +0,0 @@
|
||||
# armv7-unknown-linux-gnueabihf configuration
|
||||
CROSS_PREFIX_armv7-unknown-linux-gnueabihf=arm-linux-gnueabihf-
|
||||
CC_armv7-unknown-linux-gnueabihf=gcc
|
||||
CXX_armv7-unknown-linux-gnueabihf=g++
|
||||
CPP_armv7-unknown-linux-gnueabihf=gcc -E
|
||||
AR_armv7-unknown-linux-gnueabihf=ar
|
||||
CFG_LIB_NAME_armv7-unknown-linux-gnueabihf=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_armv7-unknown-linux-gnueabihf=lib$(1).a
|
||||
CFG_LIB_GLOB_armv7-unknown-linux-gnueabihf=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_armv7-unknown-linux-gnueabihf=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_armv7-unknown-linux-gnueabihf := -D__arm__ $(CFLAGS) -march=armv7-a
|
||||
CFG_GCCISH_CFLAGS_armv7-unknown-linux-gnueabihf := -Wall -g -fPIC -D__arm__ $(CFLAGS) -march=armv7-a
|
||||
CFG_GCCISH_CXXFLAGS_armv7-unknown-linux-gnueabihf := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_armv7-unknown-linux-gnueabihf := -shared -fPIC -g
|
||||
CFG_GCCISH_DEF_FLAG_armv7-unknown-linux-gnueabihf := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_armv7-unknown-linux-gnueabihf :=
|
||||
CFG_INSTALL_NAME_ar,-unknown-linux-gnueabihf =
|
||||
CFG_EXE_SUFFIX_armv7-unknown-linux-gnueabihf :=
|
||||
CFG_WINDOWSY_armv7-unknown-linux-gnueabihf :=
|
||||
CFG_UNIXY_armv7-unknown-linux-gnueabihf := 1
|
||||
CFG_LDPATH_armv7-unknown-linux-gnueabihf :=
|
||||
CFG_RUN_armv7-unknown-linux-gnueabihf=$(2)
|
||||
CFG_RUN_TARG_armv7-unknown-linux-gnueabihf=$(call CFG_RUN_armv7-unknown-linux-gnueabihf,,$(2))
|
||||
RUSTC_FLAGS_armv7-unknown-linux-gnueabihf :=
|
||||
RUSTC_CROSS_FLAGS_armv7-unknown-linux-gnueabihf :=
|
||||
CFG_GNU_TRIPLE_armv7-unknown-linux-gnueabihf := armv7-unknown-linux-gnueabihf
|
||||
@ -1,3 +0,0 @@
|
||||
# This file is intentially left empty to indicate that, while this target is
|
||||
# supported, it's not supported using plain GNU Make builds. Use a --rustbuild
|
||||
# instead.
|
||||
@ -1,30 +0,0 @@
|
||||
# armv7s-apple-ios configuration
|
||||
CFG_SDK_NAME_armv7s-apple-ios := iphoneos
|
||||
CFG_SDK_ARCHS_armv7s-apple-ios := armv7s
|
||||
ifneq ($(findstring darwin,$(CFG_OSTYPE)),)
|
||||
CFG_IOS_SDK_armv7s-apple-ios := $(shell xcrun --show-sdk-path -sdk iphoneos 2>/dev/null)
|
||||
CFG_IOS_SDK_FLAGS_armv7s-apple-ios := -target armv7s-apple-ios -isysroot $(CFG_IOS_SDK_armv7s-apple-ios) -mios-version-min=7.0
|
||||
CC_armv7s-apple-ios = $(shell xcrun -find -sdk iphoneos clang)
|
||||
CXX_armv7s-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
CPP_armv7s-apple-ios = $(shell xcrun -find -sdk iphoneos clang++)
|
||||
AR_armv7s-apple-ios = $(shell xcrun -find -sdk iphoneos ar)
|
||||
endif
|
||||
CFG_LIB_NAME_armv7s-apple-ios = lib$(1).a
|
||||
CFG_LIB_GLOB_armv7s-apple-ios = lib$(1)-*.a
|
||||
CFG_INSTALL_ONLY_RLIB_armv7s-apple-ios = 1
|
||||
CFG_STATIC_LIB_NAME_armv7s-apple-ios=lib$(1).a
|
||||
CFG_LIB_DSYM_GLOB_armv7s-apple-ios = lib$(1)-*.a.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_armv7s-apple-ios := -arch armv7s $(CFG_IOS_SDK_FLAGS_armv7s-apple-ios)
|
||||
CFG_GCCISH_CFLAGS_armv7s-apple-ios := -g -fPIC $(CFG_IOS_SDK_FLAGS_armv7s-apple-ios) -arch armv7s
|
||||
CFG_GCCISH_CXXFLAGS_armv7s-apple-ios := -fno-rtti $(CFG_IOS_SDK_FLAGS_armv7s-apple-ios) -I$(CFG_IOS_SDK_armv7s-apple-ios)/usr/include/c++/4.2.1
|
||||
CFG_GCCISH_LINK_FLAGS_armv7s-apple-ios := -lpthread -syslibroot $(CFG_IOS_SDK_armv7s-apple-ios) -Wl,-no_compact_unwind
|
||||
CFG_GCCISH_DEF_FLAG_armv7s-apple-ios := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_armv7s-apple-ios := -mattr=+vfp4,+v7,+neon
|
||||
CFG_INSTALL_NAME_armv7s-apple-ios = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_EXE_SUFFIX_armv7s-apple-ios :=
|
||||
CFG_WINDOWSY_armv7s-apple-ios :=
|
||||
CFG_UNIXY_armv7s-apple-ios := 1
|
||||
CFG_LDPATH_armv7s-apple-ios :=
|
||||
CFG_RUN_armv7s-apple-ios = $(2)
|
||||
CFG_RUN_TARG_armv7s-apple-ios = $(call CFG_RUN_armv7s-apple-ios,,$(2))
|
||||
CFG_GNU_TRIPLE_armv7s-apple-ios := armv7s-apple-ios
|
||||
@ -1,24 +0,0 @@
|
||||
# asmjs-unknown-emscripten configuration
|
||||
CC_asmjs-unknown-emscripten=emcc
|
||||
CXX_asmjs-unknown-emscripten=em++
|
||||
CPP_asmjs-unknown-emscripten=$(CPP)
|
||||
AR_asmjs-unknown-emscripten=emar
|
||||
CFG_LIB_NAME_asmjs-unknown-emscripten=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_asmjs-unknown-emscripten=lib$(1).a
|
||||
CFG_LIB_GLOB_asmjs-unknown-emscripten=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_asmjs-unknown-emscripten=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_asmjs-unknown-emscripten := -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_asmjs-unknown-emscripten := -g -fPIC -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_asmjs-unknown-emscripten := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_asmjs-unknown-emscripten := -shared -fPIC -ldl -pthread -lrt -g -m32
|
||||
CFG_GCCISH_DEF_FLAG_asmjs-unknown-emscripten := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_asmjs-unknown-emscripten :=
|
||||
CFG_INSTALL_NAME_asmjs-unknown-emscripten =
|
||||
CFG_EXE_SUFFIX_asmjs-unknown-emscripten =
|
||||
CFG_WINDOWSY_asmjs-unknown-emscripten :=
|
||||
CFG_UNIXY_asmjs-unknown-emscripten := 1
|
||||
CFG_LDPATH_asmjs-unknown-emscripten :=
|
||||
CFG_RUN_asmjs-unknown-emscripten=$(2)
|
||||
CFG_RUN_TARG_asmjs-unknown-emscripten=$(call CFG_RUN_asmjs-unknown-emscripten,,$(2))
|
||||
CFG_GNU_TRIPLE_asmjs-unknown-emscripten := asmjs-unknown-emscripten
|
||||
CFG_DISABLE_JEMALLOC_asmjs-unknown-emscripten := 1
|
||||
@ -1,30 +0,0 @@
|
||||
# i386-apple-ios configuration
|
||||
CFG_SDK_NAME_i386-apple-ios := iphonesimulator
|
||||
CFG_SDK_ARCHS_i386-apple-ios := i386
|
||||
ifneq ($(findstring darwin,$(CFG_OSTYPE)),)
|
||||
CFG_IOSSIM_SDK_i386-apple-ios := $(shell xcrun --show-sdk-path -sdk iphonesimulator 2>/dev/null)
|
||||
CFG_IOSSIM_FLAGS_i386-apple-ios := -m32 -target i386-apple-ios -isysroot $(CFG_IOSSIM_SDK_i386-apple-ios) -mios-simulator-version-min=7.0
|
||||
CC_i386-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang)
|
||||
CXX_i386-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang++)
|
||||
CPP_i386-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang++)
|
||||
AR_i386-apple-ios = $(shell xcrun -find -sdk iphonesimulator ar)
|
||||
endif
|
||||
CFG_LIB_NAME_i386-apple-ios = lib$(1).a
|
||||
CFG_LIB_GLOB_i386-apple-ios = lib$(1)-*.dylib
|
||||
CFG_INSTALL_ONLY_RLIB_i386-apple-ios = 1
|
||||
CFG_STATIC_LIB_NAME_i386-apple-ios=lib$(1).a
|
||||
CFG_LIB_DSYM_GLOB_i386-apple-ios = lib$(1)-*.dylib.dSYM
|
||||
CFG_GCCISH_CFLAGS_i386-apple-ios := -g -fPIC -m32 $(CFG_IOSSIM_FLAGS_i386-apple-ios)
|
||||
CFG_GCCISH_CXXFLAGS_i386-apple-ios := -fno-rtti $(CFG_IOSSIM_FLAGS_i386-apple-ios) -I$(CFG_IOSSIM_SDK_i386-apple-ios)/usr/include/c++/4.2.1
|
||||
CFG_GCCISH_LINK_FLAGS_i386-apple-ios := -lpthread -m32 -Wl,-no_compact_unwind -m32 -Wl,-syslibroot $(CFG_IOSSIM_SDK_i386-apple-ios)
|
||||
CFG_GCCISH_DEF_FLAG_i386-apple-ios := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_i386-apple-ios =
|
||||
CFG_INSTALL_NAME_i386-apple-ios = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_EXE_SUFFIX_i386-apple-ios :=
|
||||
CFG_WINDOWSY_i386-apple-ios :=
|
||||
CFG_UNIXY_i386-apple-ios := 1
|
||||
CFG_LDPATH_i386-apple-ios =
|
||||
CFG_RUN_i386-apple-ios = $(2)
|
||||
CFG_RUN_TARG_i386-apple-ios = $(call CFG_RUN_i386-apple-ios,,$(2))
|
||||
CFG_JEMALLOC_CFLAGS_i386-apple-ios = $(CFG_IOSSIM_FLAGS_i386-apple-ios) -target i386-apple-ios #-Wl,-syslibroot $(CFG_IOSSIM_SDK_i386-apple-ios) -Wl,-no_compact_unwind
|
||||
CFG_GNU_TRIPLE_i386-apple-ios := i386-apple-ios
|
||||
@ -1,28 +0,0 @@
|
||||
# i586-pc-windows-msvc configuration
|
||||
CC_i586-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
LINK_i586-pc-windows-msvc=$(CFG_MSVC_LINK_i386)
|
||||
CXX_i586-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
CPP_i586-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
AR_i586-pc-windows-msvc=$(CFG_MSVC_LIB_i386)
|
||||
CFG_LIB_NAME_i586-pc-windows-msvc=$(1).dll
|
||||
CFG_STATIC_LIB_NAME_i586-pc-windows-msvc=$(1).lib
|
||||
CFG_LIB_GLOB_i586-pc-windows-msvc=$(1)-*.{dll,lib}
|
||||
CFG_LIB_DSYM_GLOB_i586-pc-windows-msvc=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i586-pc-windows-msvc :=
|
||||
CFG_GCCISH_CFLAGS_i586-pc-windows-msvc := -MD -arch:IA32 -nologo
|
||||
CFG_GCCISH_CXXFLAGS_i586-pc-windows-msvc := -MD -arch:IA32 -nologo
|
||||
CFG_GCCISH_LINK_FLAGS_i586-pc-windows-msvc :=
|
||||
CFG_GCCISH_DEF_FLAG_i586-pc-windows-msvc :=
|
||||
CFG_LLC_FLAGS_i586-pc-windows-msvc :=
|
||||
CFG_INSTALL_NAME_i586-pc-windows-msvc =
|
||||
CFG_EXE_SUFFIX_i586-pc-windows-msvc := .exe
|
||||
CFG_WINDOWSY_i586-pc-windows-msvc := 1
|
||||
CFG_UNIXY_i586-pc-windows-msvc :=
|
||||
CFG_LDPATH_i586-pc-windows-msvc :=
|
||||
CFG_RUN_i586-pc-windows-msvc=$(2)
|
||||
CFG_RUN_TARG_i586-pc-windows-msvc=$(call CFG_RUN_i586-pc-windows-msvc,,$(2))
|
||||
CFG_GNU_TRIPLE_i586-pc-windows-msvc := i586-pc-win32
|
||||
|
||||
# Currently the build system is not configured to build jemalloc
|
||||
# with MSVC, so we omit this optional dependency.
|
||||
CFG_DISABLE_JEMALLOC_i586-pc-windows-msvc := 1
|
||||
@ -1,23 +0,0 @@
|
||||
# i586-unknown-linux-gnu configuration
|
||||
CC_i586-unknown-linux-gnu=$(CC)
|
||||
CXX_i586-unknown-linux-gnu=$(CXX)
|
||||
CPP_i586-unknown-linux-gnu=$(CPP)
|
||||
AR_i586-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_i586-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i586-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_i586-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i586-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i586-unknown-linux-gnu := -m32 $(CFLAGS) -march=pentium -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CFLAGS_i586-unknown-linux-gnu := -g -fPIC -m32 $(CFLAGS) -march=pentium -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CXXFLAGS_i586-unknown-linux-gnu := -fno-rtti $(CXXFLAGS) -march=pentium
|
||||
CFG_GCCISH_LINK_FLAGS_i586-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m32
|
||||
CFG_GCCISH_DEF_FLAG_i586-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_i586-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_i586-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_i586-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_i586-unknown-linux-gnu :=
|
||||
CFG_UNIXY_i586-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_i586-unknown-linux-gnu :=
|
||||
CFG_RUN_i586-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_i586-unknown-linux-gnu=$(call CFG_RUN_i586-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_i586-unknown-linux-gnu := i586-unknown-linux-gnu
|
||||
@ -1,23 +0,0 @@
|
||||
# i686-apple-darwin configuration
|
||||
CC_i686-apple-darwin=$(CC)
|
||||
CXX_i686-apple-darwin=$(CXX)
|
||||
CPP_i686-apple-darwin=$(CPP)
|
||||
AR_i686-apple-darwin=$(AR)
|
||||
CFG_LIB_NAME_i686-apple-darwin=lib$(1).dylib
|
||||
CFG_STATIC_LIB_NAME_i686-apple-darwin=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-apple-darwin=lib$(1)-*.dylib
|
||||
CFG_LIB_DSYM_GLOB_i686-apple-darwin=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-apple-darwin := -m32 -arch i386 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-apple-darwin := -g -fPIC -m32 -arch i386 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_i686-apple-darwin := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-apple-darwin := -dynamiclib -pthread -framework CoreServices -m32
|
||||
CFG_GCCISH_DEF_FLAG_i686-apple-darwin := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_i686-apple-darwin :=
|
||||
CFG_INSTALL_NAME_i686-apple-darwin = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_EXE_SUFFIX_i686-apple-darwin :=
|
||||
CFG_WINDOWSY_i686-apple-darwin :=
|
||||
CFG_UNIXY_i686-apple-darwin := 1
|
||||
CFG_LDPATH_i686-apple-darwin :=
|
||||
CFG_RUN_i686-apple-darwin=$(2)
|
||||
CFG_RUN_TARG_i686-apple-darwin=$(call CFG_RUN_i686-apple-darwin,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-apple-darwin := i686-apple-darwin
|
||||
@ -1,25 +0,0 @@
|
||||
# i686-linux-android configuration
|
||||
CC_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-gcc
|
||||
CXX_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-g++
|
||||
CPP_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-gcc -E
|
||||
AR_i686-linux-android=$(CFG_I686_LINUX_ANDROID_NDK)/bin/i686-linux-android-ar
|
||||
CFG_LIB_NAME_i686-linux-android=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-linux-android=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-linux-android=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i686-linux-android=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-linux-android := -D__i686__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-linux-android := -Wall -g -fPIC -D__i686__ -DANDROID -D__ANDROID__ $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_i686-linux-android := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-linux-android := -shared -fPIC -ldl -g -lm -lsupc++
|
||||
CFG_GCCISH_DEF_FLAG_i686-linux-android := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_i686-linux-android :=
|
||||
CFG_INSTALL_NAME_i686-linux-android =
|
||||
CFG_EXE_SUFFIX_i686-linux-android :=
|
||||
CFG_WINDOWSY_i686-linux-android :=
|
||||
CFG_UNIXY_i686-linux-android := 1
|
||||
CFG_LDPATH_i686-linux-android :=
|
||||
CFG_RUN_i686-linux-android=
|
||||
CFG_RUN_TARG_i686-linux-android=
|
||||
RUSTC_FLAGS_i686-linux-android :=
|
||||
RUSTC_CROSS_FLAGS_i686-linux-android :=
|
||||
CFG_GNU_TRIPLE_i686-linux-android := i686-linux-android
|
||||
@ -1,27 +0,0 @@
|
||||
# i686-pc-windows-gnu configuration
|
||||
CROSS_PREFIX_i686-pc-windows-gnu=i686-w64-mingw32-
|
||||
CC_i686-pc-windows-gnu=gcc
|
||||
CXX_i686-pc-windows-gnu=g++
|
||||
CPP_i686-pc-windows-gnu=gcc -E
|
||||
AR_i686-pc-windows-gnu=ar
|
||||
CFG_LIB_NAME_i686-pc-windows-gnu=$(1).dll
|
||||
CFG_STATIC_LIB_NAME_i686-pc-windows-gnu=$(1).lib
|
||||
CFG_LIB_GLOB_i686-pc-windows-gnu=$(1)-*.dll
|
||||
CFG_LIB_DSYM_GLOB_i686-pc-windows-gnu=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-pc-windows-gnu := -march=i686 -m32 -D_WIN32_WINNT=0x0600 -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-pc-windows-gnu := -g -m32 -D_WIN32_WINNT=0x0600 -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_i686-pc-windows-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-pc-windows-gnu := -shared -g -m32
|
||||
CFG_GCCISH_DEF_FLAG_i686-pc-windows-gnu :=
|
||||
CFG_LLC_FLAGS_i686-pc-windows-gnu :=
|
||||
CFG_INSTALL_NAME_i686-pc-windows-gnu =
|
||||
CFG_EXE_SUFFIX_i686-pc-windows-gnu := .exe
|
||||
CFG_WINDOWSY_i686-pc-windows-gnu := 1
|
||||
CFG_UNIXY_i686-pc-windows-gnu :=
|
||||
CFG_LDPATH_i686-pc-windows-gnu :=
|
||||
CFG_RUN_i686-pc-windows-gnu=$(2)
|
||||
CFG_RUN_TARG_i686-pc-windows-gnu=$(call CFG_RUN_i686-pc-windows-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-pc-windows-gnu := i686-w64-mingw32
|
||||
CFG_THIRD_PARTY_OBJECTS_i686-pc-windows-gnu := crt2.o dllcrt2.o
|
||||
CFG_INSTALLED_OBJECTS_i686-pc-windows-gnu := crt2.o dllcrt2.o rsbegin.o rsend.o
|
||||
CFG_RUSTRT_HAS_STARTUP_OBJS_i686-pc-windows-gnu := 1
|
||||
@ -1,28 +0,0 @@
|
||||
# i686-pc-windows-msvc configuration
|
||||
CC_i686-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
LINK_i686-pc-windows-msvc=$(CFG_MSVC_LINK_i386)
|
||||
CXX_i686-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
CPP_i686-pc-windows-msvc=$(CFG_MSVC_CL_i386)
|
||||
AR_i686-pc-windows-msvc=$(CFG_MSVC_LIB_i386)
|
||||
CFG_LIB_NAME_i686-pc-windows-msvc=$(1).dll
|
||||
CFG_STATIC_LIB_NAME_i686-pc-windows-msvc=$(1).lib
|
||||
CFG_LIB_GLOB_i686-pc-windows-msvc=$(1)-*.{dll,lib}
|
||||
CFG_LIB_DSYM_GLOB_i686-pc-windows-msvc=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-pc-windows-msvc :=
|
||||
CFG_GCCISH_CFLAGS_i686-pc-windows-msvc := -MD -nologo
|
||||
CFG_GCCISH_CXXFLAGS_i686-pc-windows-msvc := -MD -nologo
|
||||
CFG_GCCISH_LINK_FLAGS_i686-pc-windows-msvc :=
|
||||
CFG_GCCISH_DEF_FLAG_i686-pc-windows-msvc :=
|
||||
CFG_LLC_FLAGS_i686-pc-windows-msvc :=
|
||||
CFG_INSTALL_NAME_i686-pc-windows-msvc =
|
||||
CFG_EXE_SUFFIX_i686-pc-windows-msvc := .exe
|
||||
CFG_WINDOWSY_i686-pc-windows-msvc := 1
|
||||
CFG_UNIXY_i686-pc-windows-msvc :=
|
||||
CFG_LDPATH_i686-pc-windows-msvc :=
|
||||
CFG_RUN_i686-pc-windows-msvc=$(2)
|
||||
CFG_RUN_TARG_i686-pc-windows-msvc=$(call CFG_RUN_i686-pc-windows-msvc,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-pc-windows-msvc := i686-pc-win32
|
||||
|
||||
# Currently the build system is not configured to build jemalloc
|
||||
# with MSVC, so we omit this optional dependency.
|
||||
CFG_DISABLE_JEMALLOC_i686-pc-windows-msvc := 1
|
||||
@ -1,22 +0,0 @@
|
||||
# i686-unknown-freebsd configuration
|
||||
CC_i686-unknown-freebsd=$(CC)
|
||||
CXX_i686-unknown-freebsd=$(CXX)
|
||||
CPP_i686-unknown-freebsd=$(CPP)
|
||||
AR_i686-unknown-freebsd=$(AR)
|
||||
CFG_LIB_NAME_i686-unknown-freebsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-unknown-freebsd=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-unknown-freebsd=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i686-unknown-freebsd=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-unknown-freebsd := -m32 -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-unknown-freebsd := -g -fPIC -m32 -arch i386 -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-unknown-freebsd := -m32 -shared -fPIC -g -pthread -lrt
|
||||
CFG_GCCISH_DEF_FLAG_i686-unknown-freebsd := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_i686-unknown-freebsd :=
|
||||
CFG_INSTALL_NAME_i686-unknown-freebsd =
|
||||
CFG_EXE_SUFFIX_i686-unknown-freebsd :=
|
||||
CFG_WINDOWSY_i686-unknown-freebsd :=
|
||||
CFG_UNIXY_i686-unknown-freebsd := 1
|
||||
CFG_LDPATH_i686-unknown-freebsd :=
|
||||
CFG_RUN_i686-unknown-freebsd=$(2)
|
||||
CFG_RUN_TARG_i686-unknown-freebsd=$(call CFG_RUN_i686-unknown-freebsd,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-unknown-freebsd := i686-unknown-freebsd
|
||||
@ -1,27 +0,0 @@
|
||||
# i686-unknown-haiku configuration
|
||||
CROSS_PREFIX_i686-unknown-haiku=i586-pc-haiku-
|
||||
CC_i686-unknown-haiku=$(CC)
|
||||
CXX_i686-unknown-haiku=$(CXX)
|
||||
CPP_i686-unknown-haiku=$(CPP)
|
||||
AR_i686-unknown-haiku=$(AR)
|
||||
CFG_LIB_NAME_i686-unknown-haiku=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-unknown-haiku=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-unknown-haiku=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i686-unknown-haiku=lib$(1)-*.dylib.dSYM
|
||||
CFG_CFLAGS_i686-unknown-haiku := -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-unknown-haiku := -Wall -Werror -g -fPIC -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_i686-unknown-haiku := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-unknown-haiku := -shared -fPIC -ldl -pthread -lrt -g -m32
|
||||
CFG_GCCISH_PRE_LIB_FLAGS_i686-unknown-haiku := -Wl,-whole-archive
|
||||
CFG_GCCISH_POST_LIB_FLAGS_i686-unknown-haiku := -Wl,-no-whole-archive
|
||||
CFG_DEF_SUFFIX_i686-unknown-haiku := .linux.def
|
||||
CFG_LLC_FLAGS_i686-unknown-haiku :=
|
||||
CFG_INSTALL_NAME_i686-unknown-haiku =
|
||||
CFG_EXE_SUFFIX_i686-unknown-haiku =
|
||||
CFG_WINDOWSY_i686-unknown-haiku :=
|
||||
CFG_UNIXY_i686-unknown-haiku := 1
|
||||
CFG_PATH_MUNGE_i686-unknown-haiku := true
|
||||
CFG_LDPATH_i686-unknown-haiku :=
|
||||
CFG_RUN_i686-unknown-haiku=$(2)
|
||||
CFG_RUN_TARG_i686-unknown-haiku=$(call CFG_RUN_i686-unknown-haiku,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-unknown-haiku := i686-unknown-haiku
|
||||
@ -1,23 +0,0 @@
|
||||
# i686-unknown-linux-gnu configuration
|
||||
CC_i686-unknown-linux-gnu=$(CC)
|
||||
CXX_i686-unknown-linux-gnu=$(CXX)
|
||||
CPP_i686-unknown-linux-gnu=$(CPP)
|
||||
AR_i686-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_i686-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i686-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-unknown-linux-gnu := -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-unknown-linux-gnu := -g -fPIC -m32 $(CFLAGS) -march=i686
|
||||
CFG_GCCISH_CXXFLAGS_i686-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m32
|
||||
CFG_GCCISH_DEF_FLAG_i686-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_i686-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_i686-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_i686-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_i686-unknown-linux-gnu :=
|
||||
CFG_UNIXY_i686-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_i686-unknown-linux-gnu :=
|
||||
CFG_RUN_i686-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_i686-unknown-linux-gnu=$(call CFG_RUN_i686-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-unknown-linux-gnu := i686-unknown-linux-gnu
|
||||
@ -1,29 +0,0 @@
|
||||
# i686-unknown-linux-musl configuration
|
||||
CC_i686-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc
|
||||
CXX_i686-unknown-linux-musl=$(CXX)
|
||||
CPP_i686-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc -E
|
||||
AR_i686-unknown-linux-musl=$(AR)
|
||||
CFG_INSTALL_ONLY_RLIB_i686-unknown-linux-musl = 1
|
||||
CFG_LIB_NAME_i686-unknown-linux-musl=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-unknown-linux-musl=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-unknown-linux-musl=lib$(1)-*.so
|
||||
CFG_JEMALLOC_CFLAGS_i686-unknown-linux-musl := -m32 -Wl,-melf_i386 -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CFLAGS_i686-unknown-linux-musl := -g -fPIC -m32 -Wl,-melf_i386 -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CXXFLAGS_i686-unknown-linux-musl :=
|
||||
CFG_GCCISH_LINK_FLAGS_i686-unknown-linux-musl :=
|
||||
CFG_GCCISH_DEF_FLAG_i686-unknown-linux-musl :=
|
||||
CFG_LLC_FLAGS_i686-unknown-linux-musl :=
|
||||
CFG_INSTALL_NAME_i686-unknown-linux-musl =
|
||||
CFG_EXE_SUFFIX_i686-unknown-linux-musl =
|
||||
CFG_WINDOWSY_i686-unknown-linux-musl :=
|
||||
CFG_UNIXY_i686-unknown-linux-musl := 1
|
||||
CFG_LDPATH_i686-unknown-linux-musl :=
|
||||
CFG_RUN_i686-unknown-linux-musl=$(2)
|
||||
CFG_RUN_TARG_i686-unknown-linux-musl=$(call CFG_RUN_i686-unknown-linux-musl,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-unknown-linux-musl := i686-unknown-linux-musl
|
||||
CFG_THIRD_PARTY_OBJECTS_i686-unknown-linux-musl := crt1.o crti.o crtn.o
|
||||
CFG_INSTALLED_OBJECTS_i686-unknown-linux-musl := crt1.o crti.o crtn.o
|
||||
|
||||
NATIVE_DEPS_libc_T_i686-unknown-linux-musl += libc.a
|
||||
NATIVE_DEPS_std_T_i686-unknown-linux-musl += crt1.o crti.o crtn.o
|
||||
NATIVE_DEPS_unwind_T_i686-unknown-linux-musl += libunwind.a
|
||||
@ -1,24 +0,0 @@
|
||||
# i686-unknown-openbsd configuration
|
||||
CC_i686-unknown-openbsd=$(CC)
|
||||
CXX_i686-unknown-openbsd=$(CXX)
|
||||
CPP_i686-unknown-openbsd=$(CPP)
|
||||
AR_i686-unknown-openbsd=$(AR)
|
||||
CFG_LIB_NAME_i686-unknown-openbsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_i686-unknown-openbsd=lib$(1).a
|
||||
CFG_LIB_GLOB_i686-unknown-openbsd=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_i686-unknown-openbsd=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_i686-unknown-openbsd := -m32 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_i686-unknown-openbsd := -g -fPIC -m32 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_i686-unknown-openbsd := -shared -fPIC -g -pthread -m32
|
||||
CFG_GCCISH_DEF_FLAG_i686-unknown-openbsd := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_i686-unknown-openbsd :=
|
||||
CFG_INSTALL_NAME_i686-unknown-openbsd =
|
||||
CFG_EXE_SUFFIX_i686-unknown-openbsd :=
|
||||
CFG_WINDOWSY_i686-unknown-openbsd :=
|
||||
CFG_UNIXY_i686-unknown-openbsd := 1
|
||||
CFG_LDPATH_i686-unknown-openbsd :=
|
||||
CFG_RUN_i686-unknown-openbsd=$(2)
|
||||
CFG_RUN_TARG_i686-unknown-openbsd=$(call CFG_RUN_i686-unknown-openbsd,,$(2))
|
||||
CFG_GNU_TRIPLE_i686-unknown-openbsd := i686-unknown-openbsd
|
||||
RUSTC_FLAGS_i686-unknown-openbsd=-C linker=$(call FIND_COMPILER,$(CC))
|
||||
CFG_DISABLE_JEMALLOC_i686-unknown-openbsd := 1
|
||||
@ -1,40 +0,0 @@
|
||||
# le32-unknown-nacl (portable, PNaCl)
|
||||
ifneq ($(CFG_NACL_CROSS_PATH),)
|
||||
|
||||
CC_le32-unknown-nacl=$(shell $(CFG_PYTHON) $(CFG_NACL_CROSS_PATH)/tools/nacl_config.py -t pnacl --tool cc)
|
||||
CXX_le32-unknown-nacl=$(shell $(CFG_PYTHON) $(CFG_NACL_CROSS_PATH)/tools/nacl_config.py -t pnacl --tool c++)
|
||||
CPP_le32-unknown-nacl=$(CXX_le32-unknown-nacl) -E
|
||||
AR_le32-unknown-nacl=$(shell $(CFG_PYTHON) $(CFG_NACL_CROSS_PATH)/tools/nacl_config.py -t pnacl --tool ar)
|
||||
|
||||
CFG_PNACL_TOOLCHAIN := $(abspath $(dir $(AR_le32-unknown-nacl)/../))
|
||||
|
||||
# Note: pso's aren't supported by PNaCl.
|
||||
CFG_LIB_NAME_le32-unknown-nacl=lib$(1).pso
|
||||
CFG_STATIC_LIB_NAME_le32-unknown-nacl=lib$(1).a
|
||||
CFG_LIB_GLOB_le32-unknown-nacl=lib$(1)-*.pso
|
||||
CFG_LIB_DSYM_GLOB_le32-unknown-nacl=lib$(1)-*.dylib.dSYM
|
||||
CFG_GCCISH_CFLAGS_le32-unknown-nacl := -Wall -Wno-unused-variable -Wno-unused-value $(shell $(CFG_PYTHON) $(CFG_NACL_CROSS_PATH)/tools/nacl_config.py -t pnacl --cflags) -D_YUGA_LITTLE_ENDIAN=1 -D_YUGA_BIG_ENDIAN=0
|
||||
CFG_GCCISH_CXXFLAGS_le32-unknown-nacl := -stdlib=libc++ $(CFG_GCCISH_CFLAGS_le32-unknown-nacl)
|
||||
CFG_GCCISH_LINK_FLAGS_le32-unknown-nacl := -static -pthread -lm
|
||||
CFG_GCCISH_DEF_FLAG_le32-unknown-nacl := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_GCCISH_PRE_LIB_FLAGS_le32-unknown-nacl := -Wl,-no-whole-archive
|
||||
CFG_GCCISH_POST_LIB_FLAGS_le32-unknown-nacl :=
|
||||
CFG_DEF_SUFFIX_le32-unknown-nacl := .le32.nacl.def
|
||||
CFG_INSTALL_NAME_le32-unknown-nacl =
|
||||
CFG_EXE_SUFFIX_le32-unknown-nacl = .pexe
|
||||
CFG_WINDOWSY_le32-unknown-nacl :=
|
||||
CFG_UNIXY_le32-unknown-nacl := 1
|
||||
CFG_NACLY_le32-unknown-nacl := 1
|
||||
CFG_PATH_MUNGE_le32-unknown-nacl := true
|
||||
CFG_LDPATH_le32-unknown-nacl :=
|
||||
CFG_RUN_le32-unknown-nacl=$(2)
|
||||
CFG_RUN_TARG_le32-unknown-nacl=$(call CFG_RUN_le32-unknown-nacl,,$(2))
|
||||
RUSTC_FLAGS_le32-unknown-nacl:=
|
||||
RUSTC_CROSS_FLAGS_le32-unknown-nacl=-L $(CFG_NACL_CROSS_PATH)/lib/pnacl/Release -L $(CFG_PNACL_TOOLCHAIN)/lib/clang/3.7.0/lib/le32-nacl -L $(CFG_PNACL_TOOLCHAIN)/le32-nacl/usr/lib -L $(CFG_PNACL_TOOLCHAIN)/le32-nacl/lib
|
||||
CFG_GNU_TRIPLE_le32-unknown-nacl := le32-unknown-nacl
|
||||
|
||||
# strdup isn't defined unless -std=gnu++11 is used :/
|
||||
LLVM_FILTER_CXXFLAGS_le32-unknown-nacl := -std=c++11
|
||||
LLVM_EXTRA_CXXFLAGS_le32-unknown-nacl := -std=gnu++11
|
||||
|
||||
endif
|
||||
@ -1,24 +0,0 @@
|
||||
# mips-unknown-linux-gnu configuration
|
||||
CC_mips-unknown-linux-gnu=mips-linux-gnu-gcc
|
||||
CXX_mips-unknown-linux-gnu=mips-linux-gnu-g++
|
||||
CPP_mips-unknown-linux-gnu=mips-linux-gnu-gcc -E
|
||||
AR_mips-unknown-linux-gnu=mips-linux-gnu-ar
|
||||
CFG_LIB_NAME_mips-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_mips-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_mips-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_mips-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_mips-unknown-linux-gnu := -mips32r2 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_mips-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_mips-unknown-linux-gnu := -shared -fPIC -g -mips32r2 -mabi=32
|
||||
CFG_GCCISH_DEF_FLAG_mips-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_mips-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_mips-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_mips-unknown-linux-gnu :=
|
||||
CFG_WINDOWSY_mips-unknown-linux-gnu :=
|
||||
CFG_UNIXY_mips-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_mips-unknown-linux-gnu :=
|
||||
CFG_RUN_mips-unknown-linux-gnu=
|
||||
CFG_RUN_TARG_mips-unknown-linux-gnu=
|
||||
RUSTC_FLAGS_mips-unknown-linux-gnu :=
|
||||
CFG_GNU_TRIPLE_mips-unknown-linux-gnu := mips-unknown-linux-gnu
|
||||
@ -1,24 +0,0 @@
|
||||
# mips-unknown-linux-musl configuration
|
||||
CC_mips-unknown-linux-musl=mips-linux-musl-gcc
|
||||
CXX_mips-unknown-linux-musl=mips-linux-musl-g++
|
||||
CPP_mips-unknown-linux-musl=mips-linux-musl-gcc -E
|
||||
AR_mips-unknown-linux-musl=mips-linux-musl-ar
|
||||
CFG_LIB_NAME_mips-unknown-linux-musl=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_mips-unknown-linux-musl=lib$(1).a
|
||||
CFG_LIB_GLOB_mips-unknown-linux-musl=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_mips-unknown-linux-musl=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_mips-unknown-linux-musl := -mips32r2 -msoft-float -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_mips-unknown-linux-musl := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_mips-unknown-linux-musl := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_mips-unknown-linux-musl := -shared -fPIC -g -mips32r2 -msoft-float -mabi=32
|
||||
CFG_GCCISH_DEF_FLAG_mips-unknown-linux-musl := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_mips-unknown-linux-musl :=
|
||||
CFG_INSTALL_NAME_mips-unknown-linux-musl =
|
||||
CFG_EXE_SUFFIX_mips-unknown-linux-musl =
|
||||
CFG_WINDOWSY_mips-unknown-linux-musl :=
|
||||
CFG_UNIXY_mips-unknown-linux-musl := 1
|
||||
CFG_LDPATH_mips-unknown-linux-musl :=
|
||||
CFG_RUN_mips-unknown-linux-musl=
|
||||
CFG_RUN_TARG_mips-unknown-linux-musl=
|
||||
RUSTC_FLAGS_mips-unknown-linux-musl :=
|
||||
CFG_GNU_TRIPLE_mips-unknown-linux-musl := mips-unknown-linux-musl
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1,24 +0,0 @@
|
||||
# mipsel-unknown-linux-gnu configuration
|
||||
CC_mipsel-unknown-linux-gnu=mipsel-linux-gnu-gcc
|
||||
CXX_mipsel-unknown-linux-gnu=mipsel-linux-gnu-g++
|
||||
CPP_mipsel-unknown-linux-gnu=mipsel-linux-gnu-gcc
|
||||
AR_mipsel-unknown-linux-gnu=mipsel-linux-gnu-ar
|
||||
CFG_LIB_NAME_mipsel-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_mipsel-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_mipsel-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_mipsel-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_mipsel-unknown-linux-gnu := -mips32 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_mipsel-unknown-linux-gnu := -Wall -g -fPIC -mips32 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_mipsel-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_mipsel-unknown-linux-gnu := -shared -fPIC -g -mips32
|
||||
CFG_GCCISH_DEF_FLAG_mipsel-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_mipsel-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_mipsel-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_mipsel-unknown-linux-gnu :=
|
||||
CFG_WINDOWSY_mipsel-unknown-linux-gnu :=
|
||||
CFG_UNIXY_mipsel-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_mipsel-unknown-linux-gnu :=
|
||||
CFG_RUN_mipsel-unknown-linux-gnu=
|
||||
CFG_RUN_TARG_mipsel-unknown-linux-gnu=
|
||||
RUSTC_FLAGS_mipsel-unknown-linux-gnu :=
|
||||
CFG_GNU_TRIPLE_mipsel-unknown-linux-gnu := mipsel-unknown-linux-gnu
|
||||
@ -1,24 +0,0 @@
|
||||
# mipsel-unknown-linux-musl configuration
|
||||
CC_mipsel-unknown-linux-musl=mipsel-linux-musl-gcc
|
||||
CXX_mipsel-unknown-linux-musl=mipsel-linux-musl-g++
|
||||
CPP_mipsel-unknown-linux-musl=mipsel-linux-musl-gcc
|
||||
AR_mipsel-unknown-linux-musl=mipsel-linux-musl-ar
|
||||
CFG_LIB_NAME_mipsel-unknown-linux-musl=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_mipsel-unknown-linux-musl=lib$(1).a
|
||||
CFG_LIB_GLOB_mipsel-unknown-linux-musl=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_mipsel-unknown-linux-musl=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_mipsel-unknown-linux-musl := -mips32 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_mipsel-unknown-linux-musl := -Wall -g -fPIC -mips32 -mabi=32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_mipsel-unknown-linux-musl := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_mipsel-unknown-linux-musl := -shared -fPIC -g -mips32
|
||||
CFG_GCCISH_DEF_FLAG_mipsel-unknown-linux-musl := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_mipsel-unknown-linux-musl :=
|
||||
CFG_INSTALL_NAME_mipsel-unknown-linux-musl =
|
||||
CFG_EXE_SUFFIX_mipsel-unknown-linux-musl :=
|
||||
CFG_WINDOWSY_mipsel-unknown-linux-musl :=
|
||||
CFG_UNIXY_mipsel-unknown-linux-musl := 1
|
||||
CFG_LDPATH_mipsel-unknown-linux-musl :=
|
||||
CFG_RUN_mipsel-unknown-linux-musl=
|
||||
CFG_RUN_TARG_mipsel-unknown-linux-musl=
|
||||
RUSTC_FLAGS_mipsel-unknown-linux-musl :=
|
||||
CFG_GNU_TRIPLE_mipsel-unknown-linux-musl := mipsel-unknown-linux-musl
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1,24 +0,0 @@
|
||||
# powerpc-unknown-linux-gnu configuration
|
||||
CROSS_PREFIX_powerpc-unknown-linux-gnu=powerpc-linux-gnu-
|
||||
CC_powerpc-unknown-linux-gnu=$(CC)
|
||||
CXX_powerpc-unknown-linux-gnu=$(CXX)
|
||||
CPP_powerpc-unknown-linux-gnu=$(CPP)
|
||||
AR_powerpc-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_powerpc-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_powerpc-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_powerpc-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_powerpc-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_CFLAGS_powerpc-unknown-linux-gnu := -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_powerpc-unknown-linux-gnu := -g -fPIC -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_powerpc-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_powerpc-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m32
|
||||
CFG_GCCISH_DEF_FLAG_powerpc-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_powerpc-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_powerpc-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_powerpc-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_powerpc-unknown-linux-gnu :=
|
||||
CFG_UNIXY_powerpc-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_powerpc-unknown-linux-gnu :=
|
||||
CFG_RUN_powerpc-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_powerpc-unknown-linux-gnu=$(call CFG_RUN_powerpc-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_powerpc-unknown-linux-gnu := powerpc-unknown-linux-gnu
|
||||
@ -1,25 +0,0 @@
|
||||
# powerpc64-unknown-linux-gnu configuration
|
||||
CROSS_PREFIX_powerpc64-unknown-linux-gnu=powerpc-linux-gnu-
|
||||
CC_powerpc64-unknown-linux-gnu=$(CC)
|
||||
CXX_powerpc64-unknown-linux-gnu=$(CXX)
|
||||
CPP_powerpc64-unknown-linux-gnu=$(CPP)
|
||||
AR_powerpc64-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_powerpc64-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_powerpc64-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_powerpc64-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_powerpc64-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_powerpc64-unknown-linux-gnu := -m64
|
||||
CFG_CFLAGS_powerpc64-unknown-linux-gnu := -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_powerpc64-unknown-linux-gnu := -g -fPIC -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_powerpc64-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_powerpc64-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m64
|
||||
CFG_GCCISH_DEF_FLAG_powerpc64-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_powerpc64-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_powerpc64-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_powerpc64-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_powerpc64-unknown-linux-gnu :=
|
||||
CFG_UNIXY_powerpc64-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_powerpc64-unknown-linux-gnu :=
|
||||
CFG_RUN_powerpc64-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_powerpc64-unknown-linux-gnu=$(call CFG_RUN_powerpc64-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_powerpc64-unknown-linux-gnu := powerpc64-unknown-linux-gnu
|
||||
@ -1,24 +0,0 @@
|
||||
# powerpc64le-unknown-linux-gnu configuration
|
||||
CROSS_PREFIX_powerpc64le-unknown-linux-gnu=powerpc64le-linux-gnu-
|
||||
CC_powerpc64le-unknown-linux-gnu=$(CC)
|
||||
CXX_powerpc64le-unknown-linux-gnu=$(CXX)
|
||||
CPP_powerpc64le-unknown-linux-gnu=$(CPP)
|
||||
AR_powerpc64le-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_powerpc64le-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_powerpc64le-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_powerpc64le-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_powerpc64le-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_CFLAGS_powerpc64le-unknown-linux-gnu := -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_powerpc64le-unknown-linux-gnu := -g -fPIC -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_powerpc64le-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_powerpc64le-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m64
|
||||
CFG_GCCISH_DEF_FLAG_powerpc64le-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_powerpc64le-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_powerpc64le-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_powerpc64le-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_powerpc64le-unknown-linux-gnu :=
|
||||
CFG_UNIXY_powerpc64le-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_powerpc64le-unknown-linux-gnu :=
|
||||
CFG_RUN_powerpc64le-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_powerpc64le-unknown-linux-gnu=$(call CFG_RUN_powerpc64le-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_powerpc64le-unknown-linux-gnu := powerpc64le-unknown-linux-gnu
|
||||
@ -1,24 +0,0 @@
|
||||
# s390x-unknown-linux-gnu configuration
|
||||
CROSS_PREFIX_s390x-unknown-linux-gnu=s390x-linux-gnu-
|
||||
CC_s390x-unknown-linux-gnu=$(CC)
|
||||
CXX_s390x-unknown-linux-gnu=$(CXX)
|
||||
CPP_s390x-unknown-linux-gnu=$(CPP)
|
||||
AR_s390x-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_s390x-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_s390x-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_s390x-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_s390x-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_CFLAGS_s390x-unknown-linux-gnu := -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_s390x-unknown-linux-gnu := -g -fPIC -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_s390x-unknown-linux-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_s390x-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m64
|
||||
CFG_GCCISH_DEF_FLAG_s390x-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_s390x-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_s390x-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_s390x-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_s390x-unknown-linux-gnu :=
|
||||
CFG_UNIXY_s390x-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_s390x-unknown-linux-gnu :=
|
||||
CFG_RUN_s390x-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_s390x-unknown-linux-gnu=$(call CFG_RUN_s390x-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_s390x-unknown-linux-gnu := s390x-unknown-linux-gnu
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1,3 +0,0 @@
|
||||
# This file is intentially left empty to indicate that, while this target is
|
||||
# supported, it's not supported using plain GNU Make builds. Use a --rustbuild
|
||||
# instead.
|
||||
@ -1,24 +0,0 @@
|
||||
# wasm32-unknown-emscripten configuration
|
||||
CC_wasm32-unknown-emscripten=emcc
|
||||
CXX_wasm32-unknown-emscripten=em++
|
||||
CPP_wasm32-unknown-emscripten=$(CPP)
|
||||
AR_wasm32-unknown-emscripten=emar
|
||||
CFG_LIB_NAME_wasm32-unknown-emscripten=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_wasm32-unknown-emscripten=lib$(1).a
|
||||
CFG_LIB_GLOB_wasm32-unknown-emscripten=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_wasm32-unknown-emscripten=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_wasm32-unknown-emscripten := -m32 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_wasm32-unknown-emscripten := -g -fPIC -m32 -s BINARYEN=1 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_wasm32-unknown-emscripten := -fno-rtti -s BINARYEN=1 $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_wasm32-unknown-emscripten := -shared -fPIC -ldl -pthread -lrt -g -m32 -s BINARYEN=1
|
||||
CFG_GCCISH_DEF_FLAG_wasm32-unknown-emscripten := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_wasm32-unknown-emscripten :=
|
||||
CFG_INSTALL_NAME_wasm32-unknown-emscripten =
|
||||
CFG_EXE_SUFFIX_wasm32-unknown-emscripten =
|
||||
CFG_WINDOWSY_wasm32-unknown-emscripten :=
|
||||
CFG_UNIXY_wasm32-unknown-emscripten := 1
|
||||
CFG_LDPATH_wasm32-unknown-emscripten :=
|
||||
CFG_RUN_wasm32-unknown-emscripten=$(2)
|
||||
CFG_RUN_TARG_wasm32-unknown-emscripten=$(call CFG_RUN_wasm32-unknown-emscripten,,$(2))
|
||||
CFG_GNU_TRIPLE_wasm32-unknown-emscripten := wasm32-unknown-emscripten
|
||||
CFG_DISABLE_JEMALLOC_wasm32-unknown-emscripten := 1
|
||||
@ -1,23 +0,0 @@
|
||||
# x86_64-apple-darwin configuration
|
||||
CC_x86_64-apple-darwin=$(CC)
|
||||
CXX_x86_64-apple-darwin=$(CXX)
|
||||
CPP_x86_64-apple-darwin=$(CPP)
|
||||
AR_x86_64-apple-darwin=$(AR)
|
||||
CFG_LIB_NAME_x86_64-apple-darwin=lib$(1).dylib
|
||||
CFG_STATIC_LIB_NAME_x86_64-apple-darwin=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-apple-darwin=lib$(1)-*.dylib
|
||||
CFG_LIB_DSYM_GLOB_x86_64-apple-darwin=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-apple-darwin := -m64 -arch x86_64 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-apple-darwin := -g -fPIC -m64 -arch x86_64 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-apple-darwin := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-apple-darwin := -dynamiclib -pthread -framework CoreServices -m64
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-apple-darwin := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_x86_64-apple-darwin :=
|
||||
CFG_INSTALL_NAME_x86_64-apple-darwin = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_EXE_SUFFIX_x86_64-apple-darwin :=
|
||||
CFG_WINDOWSY_x86_64-apple-darwin :=
|
||||
CFG_UNIXY_x86_64-apple-darwin := 1
|
||||
CFG_LDPATH_x86_64-apple-darwin :=
|
||||
CFG_RUN_x86_64-apple-darwin=$(2)
|
||||
CFG_RUN_TARG_x86_64-apple-darwin=$(call CFG_RUN_x86_64-apple-darwin,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-apple-darwin := x86_64-apple-darwin
|
||||
@ -1,32 +0,0 @@
|
||||
# x86_64-apple-ios configuration
|
||||
CFG_SDK_NAME_x86_64-apple-ios := iphonesimulator
|
||||
CFG_SDK_ARCHS_x86_64-apple-ios := x86_64
|
||||
ifneq ($(findstring darwin,$(CFG_OSTYPE)),)
|
||||
CFG_IOSSIM_SDK_x86_64-apple-ios := $(shell xcrun --show-sdk-path -sdk iphonesimulator 2>/dev/null)
|
||||
CFG_IOSSIM_FLAGS_x86_64-apple-ios := -m64 -target x86_64-apple-ios -isysroot $(CFG_IOSSIM_SDK_x86_64-apple-ios) -mios-simulator-version-min=7.0
|
||||
CC_x86_64-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang)
|
||||
CXX_x86_64-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang++)
|
||||
CPP_x86_64-apple-ios = $(shell xcrun -find -sdk iphonesimulator clang++)
|
||||
AR_x86_64-apple-ios = $(shell xcrun -find -sdk iphonesimulator ar)
|
||||
endif
|
||||
CFG_LIB_NAME_x86_64-apple-ios = lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-apple-ios = lib$(1)-*.a
|
||||
CFG_INSTALL_ONLY_RLIB_x86_64-apple-ios = 1
|
||||
CFG_STATIC_LIB_NAME_x86_64-apple-ios=lib$(1).a
|
||||
CFG_LIB_DSYM_GLOB_x86_64-apple-ios = lib$(1)-*.a.dSYM
|
||||
CFG_CFLAGS_x86_64-apple-ios := $(CFG_IOSSIM_FLAGS_x86_64-apple-ios)
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-apple-ios := $(CFG_IOSSIM_FLAGS_x86_64-apple-ios)
|
||||
CFG_GCCISH_CFLAGS_x86_64-apple-ios := -fPIC $(CFG_IOSSIM_FLAGS_x86_64-apple-ios)
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-apple-ios := -fno-rtti $(CFG_IOSSIM_FLAGS_x86_64-apple-ios) -I$(CFG_IOSSIM_SDK_x86_64-apple-ios)/usr/include/c++/4.2.1
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-apple-ios := -lpthread -Wl,-no_compact_unwind -m64 -Wl,-syslibroot $(CFG_IOSSIM_SDK_x86_64-apple-ios)
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-apple-ios := -Wl,-exported_symbols_list,
|
||||
CFG_LLC_FLAGS_x86_64-apple-ios :=
|
||||
CFG_INSTALL_NAME_x86_64-apple-ios = -Wl,-install_name,@rpath/$(1)
|
||||
CFG_LIBUV_LINK_FLAGS_x86_64-apple-ios :=
|
||||
CFG_EXE_SUFFIX_x86_64-apple-ios :=
|
||||
CFG_WINDOWSY_x86_64-apple-ios :=
|
||||
CFG_UNIXY_x86_64-apple-ios := 1
|
||||
CFG_LDPATH_x86_64-apple-ios :=
|
||||
CFG_RUN_x86_64-apple-ios = $(2)
|
||||
CFG_RUN_TARG_x86_64-apple-ios = $(call CFG_RUN_x86_64-apple-ios,,$(2))
|
||||
CFG_GNU_TRIPLE_i386-apple-ios := x86_64-apple-ios
|
||||
@ -1,27 +0,0 @@
|
||||
# x86_64-pc-windows-gnu configuration
|
||||
CROSS_PREFIX_x86_64-pc-windows-gnu=x86_64-w64-mingw32-
|
||||
CC_x86_64-pc-windows-gnu=gcc
|
||||
CXX_x86_64-pc-windows-gnu=g++
|
||||
CPP_x86_64-pc-windows-gnu=gcc -E
|
||||
AR_x86_64-pc-windows-gnu=ar
|
||||
CFG_LIB_NAME_x86_64-pc-windows-gnu=$(1).dll
|
||||
CFG_STATIC_LIB_NAME_x86_64-pc-windows-gnu=$(1).lib
|
||||
CFG_LIB_GLOB_x86_64-pc-windows-gnu=$(1)-*.dll
|
||||
CFG_LIB_DSYM_GLOB_x86_64-pc-windows-gnu=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-pc-windows-gnu := -m64 -D_WIN32_WINNT=0x0600 -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-pc-windows-gnu := -g -m64 -D_WIN32_WINNT=0x0600 -D__USE_MINGW_ANSI_STDIO=1 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-pc-windows-gnu := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-pc-windows-gnu := -shared -g -m64
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-pc-windows-gnu :=
|
||||
CFG_LLC_FLAGS_x86_64-pc-windows-gnu :=
|
||||
CFG_INSTALL_NAME_x86_64-pc-windows-gnu =
|
||||
CFG_EXE_SUFFIX_x86_64-pc-windows-gnu := .exe
|
||||
CFG_WINDOWSY_x86_64-pc-windows-gnu := 1
|
||||
CFG_UNIXY_x86_64-pc-windows-gnu :=
|
||||
CFG_LDPATH_x86_64-pc-windows-gnu :=
|
||||
CFG_RUN_x86_64-pc-windows-gnu=$(2)
|
||||
CFG_RUN_TARG_x86_64-pc-windows-gnu=$(call CFG_RUN_x86_64-pc-windows-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-pc-windows-gnu := x86_64-w64-mingw32
|
||||
CFG_THIRD_PARTY_OBJECTS_x86_64-pc-windows-gnu := crt2.o dllcrt2.o
|
||||
CFG_INSTALLED_OBJECTS_x86_64-pc-windows-gnu := crt2.o dllcrt2.o rsbegin.o rsend.o
|
||||
CFG_RUSTRT_HAS_STARTUP_OBJS_x86_64-pc-windows-gnu := 1
|
||||
@ -1,28 +0,0 @@
|
||||
# x86_64-pc-windows-msvc configuration
|
||||
CC_x86_64-pc-windows-msvc=$(CFG_MSVC_CL_x86_64)
|
||||
LINK_x86_64-pc-windows-msvc=$(CFG_MSVC_LINK_x86_64)
|
||||
CXX_x86_64-pc-windows-msvc=$(CFG_MSVC_CL_x86_64)
|
||||
CPP_x86_64-pc-windows-msvc=$(CFG_MSVC_CL_x86_64)
|
||||
AR_x86_64-pc-windows-msvc=$(CFG_MSVC_LIB_x86_64)
|
||||
CFG_LIB_NAME_x86_64-pc-windows-msvc=$(1).dll
|
||||
CFG_STATIC_LIB_NAME_x86_64-pc-windows-msvc=$(1).lib
|
||||
CFG_LIB_GLOB_x86_64-pc-windows-msvc=$(1)-*.{dll,lib}
|
||||
CFG_LIB_DSYM_GLOB_x86_64-pc-windows-msvc=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-pc-windows-msvc :=
|
||||
CFG_GCCISH_CFLAGS_x86_64-pc-windows-msvc := -MD -nologo
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-pc-windows-msvc := -MD -nologo
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-pc-windows-msvc :=
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-pc-windows-msvc :=
|
||||
CFG_LLC_FLAGS_x86_64-pc-windows-msvc :=
|
||||
CFG_INSTALL_NAME_x86_64-pc-windows-msvc =
|
||||
CFG_EXE_SUFFIX_x86_64-pc-windows-msvc := .exe
|
||||
CFG_WINDOWSY_x86_64-pc-windows-msvc := 1
|
||||
CFG_UNIXY_x86_64-pc-windows-msvc :=
|
||||
CFG_LDPATH_x86_64-pc-windows-msvc :=
|
||||
CFG_RUN_x86_64-pc-windows-msvc=$(2)
|
||||
CFG_RUN_TARG_x86_64-pc-windows-msvc=$(call CFG_RUN_x86_64-pc-windows-msvc,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-pc-windows-msvc := x86_64-pc-win32
|
||||
|
||||
# Currently the build system is not configured to build jemalloc
|
||||
# with MSVC, so we omit this optional dependency.
|
||||
CFG_DISABLE_JEMALLOC_x86_64-pc-windows-msvc := 1
|
||||
@ -1,25 +0,0 @@
|
||||
# x86_64-rumprun-netbsd configuration
|
||||
CROSS_PREFIX_x86_64-rumprun-netbsd=x86_64-rumprun-netbsd-
|
||||
CC_x86_64-rumprun-netbsd=gcc
|
||||
CXX_x86_64-rumprun-netbsd=g++
|
||||
CPP_x86_64-rumprun-netbsd=gcc -E
|
||||
AR_x86_64-rumprun-netbsd=ar
|
||||
CFG_INSTALL_ONLY_RLIB_x86_64-rumprun-netbsd = 1
|
||||
CFG_LIB_NAME_x86_64-rumprun-netbsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-rumprun-netbsd=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-rumprun-netbsd=lib$(1)-*.so
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-rumprun-netbsd := -m64
|
||||
CFG_GCCISH_CFLAGS_x86_64-rumprun-netbsd := -g -fPIC -m64
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-rumprun-netbsd :=
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-rumprun-netbsd :=
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-rumprun-netbsd :=
|
||||
CFG_LLC_FLAGS_x86_64-rumprun-netbsd :=
|
||||
CFG_INSTALL_NAME_x86_64-rumprun-netbsd =
|
||||
CFG_EXE_SUFFIX_x86_64-rumprun-netbsd =
|
||||
CFG_WINDOWSY_x86_64-rumprun-netbsd :=
|
||||
CFG_UNIXY_x86_64-rumprun-netbsd := 1
|
||||
CFG_LDPATH_x86_64-rumprun-netbsd :=
|
||||
CFG_RUN_x86_64-rumprun-netbsd=$(2)
|
||||
CFG_RUN_TARG_x86_64-rumprun-netbsd=$(call CFG_RUN_x86_64-rumprun-netbsd,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-rumprun-netbsd := x86_64-rumprun-netbsd
|
||||
CFG_DISABLE_JEMALLOC_x86_64-rumprun-netbsd := 1
|
||||
@ -1,23 +0,0 @@
|
||||
# x86_64-sun-solaris configuration
|
||||
CROSS_PREFIX_x86_64-sun-solaris=x86_64-sun-solaris2.11-
|
||||
CC_x86_64-sun-solaris=$(CC)
|
||||
CXX_x86_64-sun-solaris=$(CXX)
|
||||
CPP_x86_64-sun-solaris=$(CPP)
|
||||
AR_x86_64-sun-solaris=$(AR)
|
||||
CFG_LIB_NAME_x86_64-sun-solaris=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-sun-solaris=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-sun-solaris=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-sun-solaris=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-sun-solaris := -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-sun-solaris := -g -D_POSIX_PTHREAD_SEMANTICS -fPIC -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-sun-solaris := -shared -fPIC -g -pthread -lrt
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-sun-solaris := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-sun-solaris :=
|
||||
CFG_INSTALL_NAME_x86_64-sun-solaris =
|
||||
CFG_EXE_SUFFIX_x86_64-sun-solaris :=
|
||||
CFG_WINDOWSY_x86_64-sun-solaris :=
|
||||
CFG_UNIXY_x86_64-sun-solaris := 1
|
||||
CFG_LDPATH_x86_64-sun-solaris :=
|
||||
CFG_RUN_x86_64-sun-solaris=$(2)
|
||||
CFG_RUN_TARG_x86_64-sun-solaris=$(call CFG_RUN_x86_64-sun-solaris,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-sun-solaris := x86_64-sun-solaris
|
||||
@ -1,23 +0,0 @@
|
||||
# x86_64-unknown-bitrig-elf configuration
|
||||
CC_x86_64-unknown-bitrig=$(CC)
|
||||
CXX_x86_64-unknown-bitrig=$(CXX)
|
||||
CPP_x86_64-unknown-bitrig=$(CPP)
|
||||
AR_x86_64-unknown-bitrig=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-bitrig=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-bitrig=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-bitrig=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-bitrig=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-bitrig := -m64 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-bitrig := -fPIE -fPIC -m64 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-bitrig := -shared -pic -pthread -m64 $(LDFLAGS)
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-bitrig := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-bitrig :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-bitrig =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-bitrig :=
|
||||
CFG_WINDOWSY_x86_64-unknown-bitrig :=
|
||||
CFG_UNIXY_x86_64-unknown-bitrig := 1
|
||||
CFG_LDPATH_x86_64-unknown-bitrig :=
|
||||
CFG_RUN_x86_64-unknown-bitrig=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-bitrig=$(call CFG_RUN_x86_64-unknown-bitrig,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-bitrig := x86_64-unknown-bitrig
|
||||
CFG_DISABLE_JEMALLOC_x86_64-unknown-bitrig := 1
|
||||
@ -1,22 +0,0 @@
|
||||
# x86_64-pc-dragonfly-elf configuration
|
||||
CC_x86_64-unknown-dragonfly=$(CC)
|
||||
CXX_x86_64-unknown-dragonfly=$(CXX)
|
||||
CPP_x86_64-unknown-dragonfly=$(CPP)
|
||||
AR_x86_64-unknown-dragonfly=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-dragonfly=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-dragonfly=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -g -fPIC -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread -lrt -m64
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-dragonfly := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-dragonfly :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-dragonfly =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-dragonfly :=
|
||||
CFG_WINDOWSY_x86_64-unknown-dragonfly :=
|
||||
CFG_UNIXY_x86_64-unknown-dragonfly := 1
|
||||
CFG_LDPATH_x86_64-unknown-dragonfly :=
|
||||
CFG_RUN_x86_64-unknown-dragonfly=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-dragonfly=$(call CFG_RUN_x86_64-unknown-dragonfly,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-dragonfly := x86_64-unknown-dragonfly
|
||||
@ -1,22 +0,0 @@
|
||||
# x86_64-unknown-freebsd configuration
|
||||
CC_x86_64-unknown-freebsd=$(CC)
|
||||
CXX_x86_64-unknown-freebsd=$(CXX)
|
||||
CPP_x86_64-unknown-freebsd=$(CPP)
|
||||
AR_x86_64-unknown-freebsd=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-freebsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-freebsd=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-freebsd=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-freebsd=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-freebsd := -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-freebsd := -g -fPIC -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-freebsd := -shared -fPIC -g -pthread -lrt
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-freebsd := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-freebsd :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-freebsd =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-freebsd :=
|
||||
CFG_WINDOWSY_x86_64-unknown-freebsd :=
|
||||
CFG_UNIXY_x86_64-unknown-freebsd := 1
|
||||
CFG_LDPATH_x86_64-unknown-freebsd :=
|
||||
CFG_RUN_x86_64-unknown-freebsd=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-freebsd=$(call CFG_RUN_x86_64-unknown-freebsd,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-freebsd := x86_64-unknown-freebsd
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
@ -1,27 +0,0 @@
|
||||
# x86_64-unknown-haiku configuration
|
||||
CROSS_PREFIX_x86_64-unknown-haiku=x86_64-unknown-haiku-
|
||||
CC_x86_64-unknown-haiku=$(CC)
|
||||
CXX_x86_64-unknown-haiku=$(CXX)
|
||||
CPP_x86_64-unknown-haiku=$(CPP)
|
||||
AR_x86_64-unknown-haiku=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-haiku=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-haiku=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-haiku=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-haiku=lib$(1)-*.dylib.dSYM
|
||||
CFG_CFLAGS_x86_64-unknown-haiku := -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-haiku := -Wall -Werror -g -fPIC -m64 $(CFLAGS)
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-unknown-haiku := -fno-rtti $(CXXFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-haiku := -shared -fPIC -ldl -pthread -lrt -g -m64
|
||||
CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-haiku := -Wl,-whole-archive
|
||||
CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-haiku := -Wl,-no-whole-archive
|
||||
CFG_DEF_SUFFIX_x86_64-unknown-haiku := .linux.def
|
||||
CFG_LLC_FLAGS_x86_64-unknown-haiku :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-haiku =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-haiku =
|
||||
CFG_WINDOWSY_x86_64-unknown-haiku :=
|
||||
CFG_UNIXY_x86_64-unknown-haiku := 1
|
||||
CFG_PATH_MUNGE_x86_64-unknown-haiku := true
|
||||
CFG_LDPATH_x86_64-unknown-haiku :=
|
||||
CFG_RUN_x86_64-unknown-haiku=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-haiku=$(call CFG_RUN_x86_64-unknown-haiku,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-haiku := x86_64-unknown-haiku
|
||||
@ -1,23 +0,0 @@
|
||||
# x86_64-unknown-linux-gnu configuration
|
||||
CC_x86_64-unknown-linux-gnu=$(CC)
|
||||
CXX_x86_64-unknown-linux-gnu=$(CXX)
|
||||
CPP_x86_64-unknown-linux-gnu=$(CPP)
|
||||
AR_x86_64-unknown-linux-gnu=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-linux-gnu=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-linux-gnu=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-linux-gnu=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-linux-gnu := -m64
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-linux-gnu := -g -fPIC -m64
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-unknown-linux-gnu := -fno-rtti
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-linux-gnu := -shared -fPIC -ldl -pthread -lrt -g -m64
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-linux-gnu :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-linux-gnu =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-linux-gnu =
|
||||
CFG_WINDOWSY_x86_64-unknown-linux-gnu :=
|
||||
CFG_UNIXY_x86_64-unknown-linux-gnu := 1
|
||||
CFG_LDPATH_x86_64-unknown-linux-gnu :=
|
||||
CFG_RUN_x86_64-unknown-linux-gnu=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-linux-gnu=$(call CFG_RUN_x86_64-unknown-linux-gnu,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-linux-gnu := x86_64-unknown-linux-gnu
|
||||
@ -1,29 +0,0 @@
|
||||
# x86_64-unknown-linux-musl configuration
|
||||
CC_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc
|
||||
CXX_x86_64-unknown-linux-musl=$(CXX)
|
||||
CPP_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc -E
|
||||
AR_x86_64-unknown-linux-musl=$(AR)
|
||||
CFG_INSTALL_ONLY_RLIB_x86_64-unknown-linux-musl = 1
|
||||
CFG_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-linux-musl=lib$(1)-*.so
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-linux-musl := -m64 -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-linux-musl := -g -fPIC -m64 -Wa,-mrelax-relocations=no
|
||||
CFG_GCCISH_CXXFLAGS_x86_64-unknown-linux-musl :=
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-linux-musl :=
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-linux-musl :=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-linux-musl :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-linux-musl =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-linux-musl =
|
||||
CFG_WINDOWSY_x86_64-unknown-linux-musl :=
|
||||
CFG_UNIXY_x86_64-unknown-linux-musl := 1
|
||||
CFG_LDPATH_x86_64-unknown-linux-musl :=
|
||||
CFG_RUN_x86_64-unknown-linux-musl=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-linux-musl=$(call CFG_RUN_x86_64-unknown-linux-musl,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-linux-musl := x86_64-unknown-linux-musl
|
||||
CFG_THIRD_PARTY_OBJECTS_x86_64-unknown-linux-musl := crt1.o crti.o crtn.o
|
||||
CFG_INSTALLED_OBJECTS_x86_64-unknown-linux-musl := crt1.o crti.o crtn.o
|
||||
|
||||
NATIVE_DEPS_libc_T_x86_64-unknown-linux-musl += libc.a
|
||||
NATIVE_DEPS_std_T_x86_64-unknown-linux-musl += crt1.o crti.o crtn.o
|
||||
NATIVE_DEPS_unwind_T_x86_64-unknown-linux-musl += libunwind.a
|
||||
@ -1,23 +0,0 @@
|
||||
# x86_64-unknown-netbsd configuration
|
||||
CROSS_PREFIX_x86_64-unknown-netbsd=x86_64-unknown-netbsd-
|
||||
CC_x86_64-unknown-netbsd=$(CC)
|
||||
CXX_x86_64-unknown-netbsd=$(CXX)
|
||||
CPP_x86_64-unknown-netbsd=$(CPP)
|
||||
AR_x86_64-unknown-netbsd=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-netbsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-netbsd=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-netbsd=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-netbsd=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-netbsd := -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-netbsd := -g -fPIC -I/usr/local/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-netbsd := -shared -fPIC -g -pthread -lrt
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-netbsd := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-netbsd :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-netbsd =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-netbsd :=
|
||||
CFG_WINDOWSY_x86_64-unknown-netbsd :=
|
||||
CFG_UNIXY_x86_64-unknown-netbsd := 1
|
||||
CFG_LDPATH_x86_64-unknown-netbsd :=
|
||||
CFG_RUN_x86_64-unknown-netbsd=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-netbsd=$(call CFG_RUN_x86_64-unknown-netbsd,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-netbsd := x86_64-unknown-netbsd
|
||||
@ -1,24 +0,0 @@
|
||||
# x86_64-pc-openbsd-elf configuration
|
||||
CC_x86_64-unknown-openbsd=$(CC)
|
||||
CXX_x86_64-unknown-openbsd=$(CXX)
|
||||
CPP_x86_64-unknown-openbsd=$(CPP)
|
||||
AR_x86_64-unknown-openbsd=$(AR)
|
||||
CFG_LIB_NAME_x86_64-unknown-openbsd=lib$(1).so
|
||||
CFG_STATIC_LIB_NAME_x86_64-unknown-openbsd=lib$(1).a
|
||||
CFG_LIB_GLOB_x86_64-unknown-openbsd=lib$(1)-*.so
|
||||
CFG_LIB_DSYM_GLOB_x86_64-unknown-openbsd=$(1)-*.dylib.dSYM
|
||||
CFG_JEMALLOC_CFLAGS_x86_64-unknown-openbsd := -m64 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_CFLAGS_x86_64-unknown-openbsd := -g -fPIC -m64 -I/usr/include $(CFLAGS)
|
||||
CFG_GCCISH_LINK_FLAGS_x86_64-unknown-openbsd := -shared -fPIC -g -pthread -m64
|
||||
CFG_GCCISH_DEF_FLAG_x86_64-unknown-openbsd := -Wl,--export-dynamic,--dynamic-list=
|
||||
CFG_LLC_FLAGS_x86_64-unknown-openbsd :=
|
||||
CFG_INSTALL_NAME_x86_64-unknown-openbsd =
|
||||
CFG_EXE_SUFFIX_x86_64-unknown-openbsd :=
|
||||
CFG_WINDOWSY_x86_64-unknown-openbsd :=
|
||||
CFG_UNIXY_x86_64-unknown-openbsd := 1
|
||||
CFG_LDPATH_x86_64-unknown-openbsd :=
|
||||
CFG_RUN_x86_64-unknown-openbsd=$(2)
|
||||
CFG_RUN_TARG_x86_64-unknown-openbsd=$(call CFG_RUN_x86_64-unknown-openbsd,,$(2))
|
||||
CFG_GNU_TRIPLE_x86_64-unknown-openbsd := x86_64-unknown-openbsd
|
||||
RUSTC_FLAGS_x86_64-unknown-openbsd=-C linker=$(call FIND_COMPILER,$(CC))
|
||||
CFG_DISABLE_JEMALLOC_x86_64-unknown-openbsd := 1
|
||||
@ -1 +0,0 @@
|
||||
# rustbuild-only target
|
||||
122
mk/clean.mk
122
mk/clean.mk
@ -1,122 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# Cleanup
|
||||
######################################################################
|
||||
|
||||
CLEAN_STAGE_RULES := \
|
||||
$(foreach stage, $(STAGES), \
|
||||
$(foreach host, $(CFG_HOST), \
|
||||
clean$(stage)_H_$(host) \
|
||||
$(foreach target, $(CFG_TARGET), \
|
||||
clean$(stage)_T_$(target)_H_$(host))))
|
||||
|
||||
CLEAN_STAGE_RULES := $(CLEAN_STAGE_RULES) \
|
||||
$(foreach host, $(CFG_HOST), clean-generic-H-$(host))
|
||||
|
||||
CLEAN_STAGE_RULES := $(CLEAN_STAGE_RULES) \
|
||||
$(foreach host, $(CFG_TARGET), clean-generic-T-$(host))
|
||||
|
||||
CLEAN_LLVM_RULES = \
|
||||
$(foreach target, $(CFG_HOST), \
|
||||
clean-llvm$(target))
|
||||
|
||||
.PHONY: clean clean-all clean-misc clean-llvm
|
||||
|
||||
clean-all: clean clean-llvm
|
||||
|
||||
clean-llvm: $(CLEAN_LLVM_RULES)
|
||||
|
||||
clean: clean-misc clean-grammar $(CLEAN_STAGE_RULES)
|
||||
|
||||
clean-misc:
|
||||
@$(call E, cleaning)
|
||||
$(Q)rm -f $(RUNTIME_OBJS) $(RUNTIME_DEF)
|
||||
$(Q)rm -f $(RUSTLLVM_LIB_OBJS) $(RUSTLLVM_OBJS_OBJS) $(RUSTLLVM_DEF)
|
||||
$(Q)rm -Rf $(GENERATED)
|
||||
$(Q)rm -Rf tmp/*
|
||||
$(Q)rm -Rf rust-stage0-*.tar.bz2 $(PKG_NAME)-*.tar.gz $(PKG_NAME)-*.exe
|
||||
$(Q)rm -Rf dist/*
|
||||
$(Q)rm -Rf doc
|
||||
|
||||
clean-grammar:
|
||||
@$(call E, cleaning grammar verification)
|
||||
$(Q)rm -Rf grammar
|
||||
define CLEAN_GENERIC
|
||||
|
||||
clean-generic-$(2)-$(1):
|
||||
$(Q)find $(1)/rustllvm \
|
||||
$(1)/rt \
|
||||
$(1)/test \
|
||||
$(1)/stage* \
|
||||
-type f \( \
|
||||
-name '*.[odasS]' -o \
|
||||
-name '*.so' -o \
|
||||
-name '*.dylib' -o \
|
||||
-name '*.rlib' -o \
|
||||
-name 'stamp.*' -o \
|
||||
-name '*.lib' -o \
|
||||
-name '*.dll' -o \
|
||||
-name '*.def' -o \
|
||||
-name '*.py' -o \
|
||||
-name '*.pyc' -o \
|
||||
-name '*.bc' -o \
|
||||
-name '*.rs' \
|
||||
\) \
|
||||
| xargs rm -f
|
||||
$(Q)find $(1) \
|
||||
-name '*.dSYM' \
|
||||
| xargs rm -Rf
|
||||
endef
|
||||
|
||||
$(foreach host, $(CFG_HOST), $(eval $(call CLEAN_GENERIC,$(host),H)))
|
||||
$(foreach targ, $(CFG_TARGET), $(eval $(call CLEAN_GENERIC,$(targ),T)))
|
||||
|
||||
define CLEAN_HOST_STAGE_N
|
||||
|
||||
clean$(1)_H_$(2): \
|
||||
$$(foreach crate,$$(CRATES),clean$(1)_H_$(2)-lib-$$(crate)) \
|
||||
$$(foreach tool,$$(TOOLS) $$(DEBUGGER_BIN_SCRIPTS_ALL),clean$(1)_H_$(2)-tool-$$(tool))
|
||||
$$(Q)rm -fr $(2)/rt/libbacktrace
|
||||
|
||||
clean$(1)_H_$(2)-tool-%:
|
||||
$$(Q)rm -f $$(HBIN$(1)_H_$(2))/$$*$$(X_$(2))
|
||||
|
||||
clean$(1)_H_$(2)-lib-%:
|
||||
$$(Q)rm -f $$(HLIB$(1)_H_$(2))/$$(call CFG_LIB_GLOB_$(2),$$*)
|
||||
$$(Q)rm -f $$(HLIB$(1)_H_$(2))/$$(call CFG_RLIB_GLOB,$$*)
|
||||
|
||||
endef
|
||||
|
||||
$(foreach host, $(CFG_HOST), \
|
||||
$(eval $(foreach stage, $(STAGES), \
|
||||
$(eval $(call CLEAN_HOST_STAGE_N,$(stage),$(host))))))
|
||||
|
||||
define CLEAN_TARGET_STAGE_N
|
||||
|
||||
clean$(1)_T_$(2)_H_$(3): \
|
||||
$$(foreach crate,$$(CRATES),clean$(1)_T_$(2)_H_$(3)-lib-$$(crate)) \
|
||||
$$(foreach tool,$$(TOOLS) $$(DEBUGGER_BIN_SCRIPTS_ALL),clean$(1)_T_$(2)_H_$(3)-tool-$$(tool))
|
||||
$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/librun_pass_stage* # For unix
|
||||
$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/run_pass_stage* # For windows
|
||||
|
||||
clean$(1)_T_$(2)_H_$(3)-tool-%:
|
||||
$$(Q)rm -f $$(TBIN$(1)_T_$(2)_H_$(3))/$$*$$(X_$(2))
|
||||
|
||||
clean$(1)_T_$(2)_H_$(3)-lib-%:
|
||||
$$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$$(call CFG_LIB_GLOB_$(2),$$*)
|
||||
$$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$$(call CFG_RLIB_GLOB,$$*)
|
||||
endef
|
||||
|
||||
$(foreach host, $(CFG_HOST), \
|
||||
$(eval $(foreach target, $(CFG_TARGET), \
|
||||
$(eval $(foreach stage, 0 1 2 3, \
|
||||
$(eval $(call CLEAN_TARGET_STAGE_N,$(stage),$(target),$(host))))))))
|
||||
228
mk/crates.mk
228
mk/crates.mk
@ -1,228 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
################################################################################
|
||||
# Rust's standard distribution of crates and tools
|
||||
#
|
||||
# The crates outlined below are the standard distribution of libraries provided
|
||||
# in a rust installation. These rules are meant to abstract over the
|
||||
# dependencies (both native and rust) of crates and basically generate all the
|
||||
# necessary makefile rules necessary to build everything.
|
||||
#
|
||||
# Here's an explanation of the variables below
|
||||
#
|
||||
# TARGET_CRATES
|
||||
# This list of crates will be built for all targets, including
|
||||
# cross-compiled targets
|
||||
#
|
||||
# HOST_CRATES
|
||||
# This list of crates will be compiled for only host targets. Note that
|
||||
# this set is explicitly *not* a subset of TARGET_CRATES, but rather it is
|
||||
# a disjoint set. Nothing in the TARGET_CRATES set can depend on crates in
|
||||
# the HOST_CRATES set, but the HOST_CRATES set can depend on target
|
||||
# crates.
|
||||
#
|
||||
# TOOLS
|
||||
# A list of all tools which will be built as part of the compilation
|
||||
# process. It is currently assumed that most tools are built through
|
||||
# src/driver/driver.rs with a particular configuration (there's a
|
||||
# corresponding library providing the implementation)
|
||||
#
|
||||
# DEPS_<crate>
|
||||
# These lists are the dependencies of the <crate> that is to be built.
|
||||
# Rust dependencies are listed bare (i.e. std) and native
|
||||
# dependencies have a "native:" prefix (i.e. native:hoedown). All deps
|
||||
# will be built before the crate itself is built.
|
||||
#
|
||||
# TOOL_DEPS_<tool>/TOOL_SOURCE_<tool>
|
||||
# Similar to the DEPS variable, this is the library crate dependencies
|
||||
# list for tool as well as the source file for the specified tool
|
||||
#
|
||||
# You shouldn't need to modify much other than these variables. Crates are
|
||||
# automatically generated for all stage/host/target combinations.
|
||||
################################################################################
|
||||
|
||||
TARGET_CRATES := libc std term \
|
||||
getopts collections test rand \
|
||||
compiler_builtins core alloc \
|
||||
std_unicode rustc_bitflags \
|
||||
alloc_system alloc_jemalloc \
|
||||
panic_abort panic_unwind unwind
|
||||
RUSTC_CRATES := rustc rustc_typeck rustc_mir rustc_borrowck rustc_resolve rustc_driver \
|
||||
rustc_trans rustc_back rustc_llvm rustc_privacy rustc_lint \
|
||||
rustc_data_structures rustc_platform_intrinsics rustc_errors \
|
||||
rustc_plugin rustc_metadata rustc_passes rustc_save_analysis \
|
||||
rustc_const_eval rustc_const_math rustc_incremental proc_macro
|
||||
HOST_CRATES := syntax syntax_ext proc_macro_plugin syntax_pos $(RUSTC_CRATES) \
|
||||
rustdoc fmt_macros flate arena graphviz log serialize
|
||||
TOOLS := compiletest rustdoc rustc rustbook error_index_generator
|
||||
|
||||
DEPS_core :=
|
||||
DEPS_compiler_builtins := core native:compiler-rt
|
||||
DEPS_alloc := core libc alloc_system
|
||||
DEPS_alloc_system := core libc
|
||||
DEPS_alloc_jemalloc := core libc native:jemalloc
|
||||
DEPS_collections := core alloc std_unicode
|
||||
DEPS_libc := core
|
||||
DEPS_rand := core
|
||||
DEPS_rustc_bitflags := core
|
||||
DEPS_std_unicode := core
|
||||
DEPS_panic_abort := libc alloc
|
||||
DEPS_panic_unwind := libc alloc unwind
|
||||
DEPS_unwind := libc
|
||||
|
||||
RUSTFLAGS_compiler_builtins := -lstatic=compiler-rt
|
||||
RUSTFLAGS_panic_abort := -C panic=abort
|
||||
|
||||
DEPS_std := core libc rand alloc collections compiler_builtins std_unicode \
|
||||
native:backtrace \
|
||||
alloc_system panic_abort panic_unwind unwind
|
||||
DEPS_arena := std
|
||||
DEPS_glob := std
|
||||
DEPS_flate := std native:miniz
|
||||
DEPS_fmt_macros = std
|
||||
DEPS_getopts := std
|
||||
DEPS_graphviz := std
|
||||
DEPS_log := std
|
||||
DEPS_num := std
|
||||
DEPS_serialize := std log
|
||||
DEPS_term := std
|
||||
DEPS_test := std getopts term native:rust_test_helpers
|
||||
|
||||
DEPS_syntax := std term serialize log arena libc rustc_bitflags std_unicode rustc_errors \
|
||||
syntax_pos rustc_data_structures
|
||||
DEPS_syntax_ext := syntax syntax_pos rustc_errors fmt_macros proc_macro
|
||||
DEPS_proc_macro := syntax syntax_pos rustc_plugin log
|
||||
DEPS_syntax_pos := serialize
|
||||
DEPS_proc_macro_plugin := syntax syntax_pos rustc_plugin
|
||||
|
||||
DEPS_rustc_const_math := std syntax log serialize
|
||||
DEPS_rustc_const_eval := rustc_const_math rustc syntax log serialize \
|
||||
rustc_back graphviz syntax_pos
|
||||
|
||||
DEPS_rustc := syntax fmt_macros flate arena serialize getopts \
|
||||
log graphviz rustc_llvm rustc_back rustc_data_structures\
|
||||
rustc_const_math syntax_pos rustc_errors
|
||||
DEPS_rustc_back := std syntax flate log libc
|
||||
DEPS_rustc_borrowck := rustc log graphviz syntax syntax_pos rustc_errors rustc_mir
|
||||
DEPS_rustc_data_structures := std log serialize libc
|
||||
DEPS_rustc_driver := arena flate getopts graphviz libc rustc rustc_back rustc_borrowck \
|
||||
rustc_typeck rustc_mir rustc_resolve log syntax serialize rustc_llvm \
|
||||
rustc_trans rustc_privacy rustc_lint rustc_plugin \
|
||||
rustc_metadata syntax_ext proc_macro_plugin \
|
||||
rustc_passes rustc_save_analysis rustc_const_eval \
|
||||
rustc_incremental syntax_pos rustc_errors proc_macro rustc_data_structures
|
||||
DEPS_rustc_errors := log libc serialize syntax_pos
|
||||
DEPS_rustc_lint := rustc log syntax syntax_pos rustc_const_eval
|
||||
DEPS_rustc_llvm := native:rustllvm libc std rustc_bitflags
|
||||
DEPS_proc_macro := std syntax
|
||||
DEPS_rustc_metadata := rustc syntax syntax_pos rustc_errors rustc_const_math \
|
||||
proc_macro syntax_ext
|
||||
DEPS_rustc_passes := syntax syntax_pos rustc core rustc_const_eval rustc_errors
|
||||
DEPS_rustc_mir := rustc syntax syntax_pos rustc_const_math rustc_const_eval rustc_bitflags
|
||||
DEPS_rustc_resolve := arena rustc log syntax syntax_pos rustc_errors
|
||||
DEPS_rustc_platform_intrinsics := std
|
||||
DEPS_rustc_plugin := rustc rustc_metadata syntax syntax_pos rustc_errors
|
||||
DEPS_rustc_privacy := rustc log syntax syntax_pos
|
||||
DEPS_rustc_trans := arena flate getopts graphviz libc rustc rustc_back \
|
||||
log syntax serialize rustc_llvm rustc_platform_intrinsics \
|
||||
rustc_const_math rustc_const_eval rustc_incremental rustc_errors syntax_pos
|
||||
DEPS_rustc_incremental := rustc syntax_pos serialize rustc_data_structures
|
||||
DEPS_rustc_save_analysis := rustc log syntax syntax_pos serialize
|
||||
DEPS_rustc_typeck := rustc syntax syntax_pos rustc_platform_intrinsics rustc_const_math \
|
||||
rustc_const_eval rustc_errors rustc_data_structures
|
||||
|
||||
DEPS_rustdoc := rustc rustc_driver native:hoedown serialize getopts test \
|
||||
rustc_lint rustc_const_eval syntax_pos rustc_data_structures
|
||||
|
||||
TOOL_DEPS_compiletest := test getopts log serialize
|
||||
TOOL_DEPS_rustdoc := rustdoc
|
||||
TOOL_DEPS_rustc := rustc_driver
|
||||
TOOL_DEPS_rustbook := std rustdoc
|
||||
TOOL_DEPS_error_index_generator := rustdoc syntax serialize
|
||||
TOOL_SOURCE_compiletest := $(S)src/tools/compiletest/src/main.rs
|
||||
TOOL_SOURCE_rustdoc := $(S)src/driver/driver.rs
|
||||
TOOL_SOURCE_rustc := $(S)src/driver/driver.rs
|
||||
TOOL_SOURCE_rustbook := $(S)src/tools/rustbook/main.rs
|
||||
TOOL_SOURCE_error_index_generator := $(S)src/tools/error_index_generator/main.rs
|
||||
|
||||
ONLY_RLIB_compiler_builtins := 1
|
||||
ONLY_RLIB_core := 1
|
||||
ONLY_RLIB_libc := 1
|
||||
ONLY_RLIB_alloc := 1
|
||||
ONLY_RLIB_rand := 1
|
||||
ONLY_RLIB_collections := 1
|
||||
ONLY_RLIB_std_unicode := 1
|
||||
ONLY_RLIB_rustc_bitflags := 1
|
||||
ONLY_RLIB_alloc_system := 1
|
||||
ONLY_RLIB_alloc_jemalloc := 1
|
||||
ONLY_RLIB_panic_unwind := 1
|
||||
ONLY_RLIB_panic_abort := 1
|
||||
ONLY_RLIB_unwind := 1
|
||||
|
||||
TARGET_SPECIFIC_alloc_jemalloc := 1
|
||||
|
||||
# Documented-by-default crates
|
||||
DOC_CRATES := std alloc collections core libc std_unicode
|
||||
|
||||
ifeq ($(CFG_DISABLE_JEMALLOC),)
|
||||
RUSTFLAGS_rustc_back := --cfg 'feature="jemalloc"'
|
||||
endif
|
||||
|
||||
################################################################################
|
||||
# You should not need to edit below this line
|
||||
################################################################################
|
||||
|
||||
CRATES := $(TARGET_CRATES) $(HOST_CRATES)
|
||||
|
||||
# This macro creates some simple definitions for each crate being built, just
|
||||
# some munging of all of the parameters above.
|
||||
#
|
||||
# $(1) is the crate to generate variables for
|
||||
define RUST_CRATE
|
||||
CRATEFILE_$(1) := $$(SREL)src/lib$(1)/lib.rs
|
||||
RSINPUTS_$(1) := $$(call rwildcard,$(S)src/lib$(1)/,*.rs)
|
||||
NATIVE_DEPS_$(1) := $$(patsubst native:%,%,$$(filter native:%,$$(DEPS_$(1))))
|
||||
endef
|
||||
|
||||
$(foreach crate,$(CRATES),$(eval $(call RUST_CRATE,$(crate))))
|
||||
|
||||
# $(1) - crate
|
||||
# $(2) - target
|
||||
define RUST_CRATE_DEPS
|
||||
RUST_DEPS_$(1)_T_$(2) := $$(filter-out native:%,$$(DEPS_$(1)))
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET),\
|
||||
$(foreach crate,$(CRATES),$(eval $(call RUST_CRATE_DEPS,$(crate),$(target)))))
|
||||
|
||||
# $(1) - target
|
||||
# $(2) - crate
|
||||
define DEFINE_TARGET_CRATES
|
||||
ifndef TARGET_SPECIFIC_$(2)
|
||||
TARGET_CRATES_$(1) += $(2)
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET),\
|
||||
$(foreach crate,$(TARGET_CRATES),\
|
||||
$(eval $(call DEFINE_TARGET_CRATES,$(target),$(crate)))))
|
||||
|
||||
# Similar to the macro above for crates, this macro is for tools
|
||||
#
|
||||
# $(1) is the crate to generate variables for
|
||||
define RUST_TOOL
|
||||
TOOL_INPUTS_$(1) := $$(call rwildcard,$$(dir $$(TOOL_SOURCE_$(1))),*.rs)
|
||||
endef
|
||||
|
||||
$(foreach crate,$(TOOLS),$(eval $(call RUST_TOOL,$(crate))))
|
||||
|
||||
CRATEFILE_libc := $(SREL)src/liblibc/src/lib.rs
|
||||
RUSTFLAGS_libc := --cfg stdbuild
|
||||
35
mk/ctags.mk
35
mk/ctags.mk
@ -1,35 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# TAGS file creation. No dependency tracking, just do it on demand.
|
||||
# Requires Exuberant Ctags: http://ctags.sourceforge.net/index.html
|
||||
######################################################################
|
||||
|
||||
.PHONY: TAGS.emacs TAGS.vi
|
||||
|
||||
CTAGS_RUSTC_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/lib%test,, \
|
||||
$(wildcard ${CFG_SRC_DIR}src/lib*)) ${CFG_SRC_DIR}src/libtest
|
||||
CTAGS_LOCATIONS=$(patsubst ${CFG_SRC_DIR}src/librust%,, \
|
||||
$(patsubst ${CFG_SRC_DIR}src/lib%test,, \
|
||||
$(wildcard ${CFG_SRC_DIR}src/lib*))) ${CFG_SRC_DIR}src/libtest
|
||||
CTAGS_OPTS=--options="${CFG_SRC_DIR}src/etc/ctags.rust" --languages=Rust --recurse
|
||||
|
||||
TAGS.rustc.emacs:
|
||||
ctags -e -f $@ ${CTAGS_OPTS} ${CTAGS_RUSTC_LOCATIONS}
|
||||
|
||||
TAGS.emacs:
|
||||
ctags -e -f $@ ${CTAGS_OPTS} ${CTAGS_LOCATIONS}
|
||||
|
||||
TAGS.rustc.vi:
|
||||
ctags -f $@ ${CTAGS_OPTS} ${CTAGS_RUSTC_LOCATIONS}
|
||||
|
||||
TAGS.vi:
|
||||
ctags -f $@ ${CTAGS_OPTS} ${CTAGS_LOCATIONS}
|
||||
145
mk/debuggers.mk
145
mk/debuggers.mk
@ -1,145 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# Copy debugger related scripts
|
||||
######################################################################
|
||||
|
||||
|
||||
## GDB ##
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB=gdb_load_rust_pretty_printers.py \
|
||||
gdb_rust_pretty_printing.py \
|
||||
debugger_pretty_printers_common.py
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS=\
|
||||
$(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB), \
|
||||
$(CFG_SRC_DIR)src/etc/$(script))
|
||||
|
||||
DEBUGGER_BIN_SCRIPTS_GDB=rust-gdb
|
||||
DEBUGGER_BIN_SCRIPTS_GDB_ABS=\
|
||||
$(foreach script,$(DEBUGGER_BIN_SCRIPTS_GDB), \
|
||||
$(CFG_SRC_DIR)src/etc/$(script))
|
||||
|
||||
|
||||
## LLDB ##
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB=lldb_rust_formatters.py \
|
||||
debugger_pretty_printers_common.py
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS=\
|
||||
$(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB), \
|
||||
$(CFG_SRC_DIR)src/etc/$(script))
|
||||
|
||||
DEBUGGER_BIN_SCRIPTS_LLDB=rust-lldb
|
||||
DEBUGGER_BIN_SCRIPTS_LLDB_ABS=\
|
||||
$(foreach script,$(DEBUGGER_BIN_SCRIPTS_LLDB), \
|
||||
$(CFG_SRC_DIR)src/etc/$(script))
|
||||
|
||||
|
||||
## ALL ##
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL=gdb_load_rust_pretty_printers.py \
|
||||
gdb_rust_pretty_printing.py \
|
||||
lldb_rust_formatters.py \
|
||||
debugger_pretty_printers_common.py
|
||||
DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS=\
|
||||
$(foreach script,$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL), \
|
||||
$(CFG_SRC_DIR)src/etc/$(script))
|
||||
DEBUGGER_BIN_SCRIPTS_ALL=$(DEBUGGER_BIN_SCRIPTS_GDB) \
|
||||
$(DEBUGGER_BIN_SCRIPTS_LLDB)
|
||||
DEBUGGER_BIN_SCRIPTS_ALL_ABS=$(DEBUGGER_BIN_SCRIPTS_GDB_ABS) \
|
||||
$(DEBUGGER_BIN_SCRIPTS_LLDB_ABS)
|
||||
|
||||
|
||||
# $(1) - the stage to copy to
|
||||
# $(2) - the host triple
|
||||
define DEF_INSTALL_DEBUGGER_SCRIPTS_HOST
|
||||
|
||||
tmp/install-debugger-scripts$(1)_H_$(2)-gdb.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_GDB_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(HBIN$(1)_H_$(2))
|
||||
$(Q)mkdir -p $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)install $$(DEBUGGER_BIN_SCRIPTS_GDB_ABS) $$(HBIN$(1)_H_$(2))
|
||||
$(Q)install $$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS) $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_H_$(2)-lldb.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_LLDB_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(HBIN$(1)_H_$(2))
|
||||
$(Q)mkdir -p $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)install $$(DEBUGGER_BIN_SCRIPTS_LLDB_ABS) $$(HBIN$(1)_H_$(2))
|
||||
$(Q)install $$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS) $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_H_$(2)-all.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_ALL_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(HBIN$(1)_H_$(2))
|
||||
$(Q)mkdir -p $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)install $$(DEBUGGER_BIN_SCRIPTS_ALL_ABS) $$(HBIN$(1)_H_$(2))
|
||||
$(Q)install $$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS) $$(HLIB$(1)_H_$(2))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_H_$(2)-none.done:
|
||||
$(Q)touch $$@
|
||||
|
||||
endef
|
||||
|
||||
# Expand host make-targets for all stages
|
||||
$(foreach stage,$(STAGES), \
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call DEF_INSTALL_DEBUGGER_SCRIPTS_HOST,$(stage),$(host)))))
|
||||
|
||||
# $(1) is the stage number
|
||||
# $(2) is the target triple
|
||||
# $(3) is the host triple
|
||||
define DEF_INSTALL_DEBUGGER_SCRIPTS_TARGET
|
||||
|
||||
tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3)-gdb.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_GDB_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)mkdir -p $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)install $(DEBUGGER_BIN_SCRIPTS_GDB_ABS) $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)install $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS) $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3)-lldb.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_LLDB_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)mkdir -p $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)install $(DEBUGGER_BIN_SCRIPTS_LLDB_ABS) $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)install $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS) $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3)-all.done: \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_ALL_ABS)
|
||||
$(Q)touch $$@.start_time
|
||||
$(Q)mkdir -p $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)mkdir -p $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)install $(DEBUGGER_BIN_SCRIPTS_ALL_ABS) $$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
$(Q)install $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS) $$(TLIB$(1)_T_$(2)_H_$(3))/rustlib/etc
|
||||
$(Q)touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
|
||||
tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3)-none.done:
|
||||
$(Q)touch $$@
|
||||
|
||||
endef
|
||||
|
||||
# Expand target make-targets for all stages
|
||||
$(foreach stage,$(STAGES), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call DEF_INSTALL_DEBUGGER_SCRIPTS_TARGET,$(stage),$(target),$(host))))))
|
||||
382
mk/dist.mk
382
mk/dist.mk
@ -1,382 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# Distribution
|
||||
######################################################################
|
||||
|
||||
# Primary targets:
|
||||
#
|
||||
# * dist - make all distribution artifacts
|
||||
# * distcheck - sanity check dist artifacts
|
||||
# * dist-tar-src - source tarballs
|
||||
# * dist-tar-bins - Ad-hoc Unix binary installers
|
||||
# * dist-docs - Stage docs for upload
|
||||
|
||||
PKG_NAME := $(CFG_PACKAGE_NAME)
|
||||
STD_PKG_NAME := rust-std-$(CFG_PACKAGE_VERS)
|
||||
DOC_PKG_NAME := rust-docs-$(CFG_PACKAGE_VERS)
|
||||
MINGW_PKG_NAME := rust-mingw-$(CFG_PACKAGE_VERS)
|
||||
SRC_PKG_NAME := rust-src-$(CFG_PACKAGE_VERS)
|
||||
|
||||
# License suitable for displaying in a popup
|
||||
LICENSE.txt: $(S)COPYRIGHT $(S)LICENSE-APACHE $(S)LICENSE-MIT
|
||||
cat $^ > $@
|
||||
|
||||
|
||||
######################################################################
|
||||
# Source tarball
|
||||
######################################################################
|
||||
|
||||
PKG_TAR = dist/$(PKG_NAME)-src.tar.gz
|
||||
|
||||
PKG_GITMODULES := $(S)src/llvm $(S)src/compiler-rt \
|
||||
$(S)src/rt/hoedown $(S)src/jemalloc
|
||||
PKG_FILES := \
|
||||
$(S)COPYRIGHT \
|
||||
$(S)LICENSE-APACHE \
|
||||
$(S)LICENSE-MIT \
|
||||
$(S)CONTRIBUTING.md \
|
||||
$(S)README.md \
|
||||
$(S)RELEASES.md \
|
||||
$(S)configure $(S)Makefile.in \
|
||||
$(S)man \
|
||||
$(addprefix $(S)src/, \
|
||||
bootstrap \
|
||||
build_helper \
|
||||
doc \
|
||||
driver \
|
||||
etc \
|
||||
$(foreach crate,$(CRATES),lib$(crate)) \
|
||||
libcollectionstest \
|
||||
libcoretest \
|
||||
libbacktrace \
|
||||
rt \
|
||||
rtstartup \
|
||||
rustllvm \
|
||||
rustc \
|
||||
stage0.txt \
|
||||
rust-installer \
|
||||
tools \
|
||||
test \
|
||||
vendor) \
|
||||
$(PKG_GITMODULES) \
|
||||
$(filter-out config.stamp, \
|
||||
$(MKFILES_FOR_TARBALL))
|
||||
|
||||
UNROOTED_PKG_FILES := $(patsubst $(S)%,./%,$(PKG_FILES))
|
||||
|
||||
tmp/dist/$$(SRC_PKG_NAME)-image: $(PKG_FILES)
|
||||
@$(call E, making src image)
|
||||
$(Q)rm -Rf tmp/dist/$(SRC_PKG_NAME)-image
|
||||
$(Q)mkdir -p tmp/dist/$(SRC_PKG_NAME)-image/lib/rustlib/src/rust
|
||||
$(Q)echo "$(CFG_VERSION)" > tmp/dist/$(SRC_PKG_NAME)-image/lib/rustlib/src/rust/version
|
||||
$(Q)tar \
|
||||
-C $(S) \
|
||||
-f - \
|
||||
--exclude-vcs \
|
||||
--exclude=*~ \
|
||||
--exclude=*.pyc \
|
||||
--exclude=*/llvm/test/*/*.ll \
|
||||
--exclude=*/llvm/test/*/*.td \
|
||||
--exclude=*/llvm/test/*/*.s \
|
||||
--exclude=*/llvm/test/*/*/*.ll \
|
||||
--exclude=*/llvm/test/*/*/*.td \
|
||||
--exclude=*/llvm/test/*/*/*.s \
|
||||
-c $(UNROOTED_PKG_FILES) | tar -x -f - -C tmp/dist/$(SRC_PKG_NAME)-image/lib/rustlib/src/rust
|
||||
|
||||
$(PKG_TAR): tmp/dist/$$(SRC_PKG_NAME)-image
|
||||
@$(call E, making $@)
|
||||
$(Q)tar -czf $(PKG_TAR) -C tmp/dist/$(SRC_PKG_NAME)-image/lib/rustlib/src rust --transform 's,^rust,$(PKG_NAME),S'
|
||||
|
||||
dist-tar-src: $(PKG_TAR)
|
||||
|
||||
distcheck-tar-src: dist-tar-src
|
||||
$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)
|
||||
$(Q)rm -Rf tmp/distcheck/srccheck
|
||||
$(Q)mkdir -p tmp/distcheck
|
||||
@$(call E, unpacking $(PKG_TAR) in tmp/distcheck/$(PKG_NAME))
|
||||
$(Q)cd tmp/distcheck && tar -xzf ../../$(PKG_TAR)
|
||||
@$(call E, configuring in tmp/distcheck/srccheck)
|
||||
$(Q)mkdir -p tmp/distcheck/srccheck
|
||||
$(Q)cd tmp/distcheck/srccheck && ../$(PKG_NAME)/configure
|
||||
@$(call E, making 'check' in tmp/distcheck/srccheck)
|
||||
$(Q)+make -C tmp/distcheck/srccheck check
|
||||
@$(call E, making 'clean' in tmp/distcheck/srccheck)
|
||||
$(Q)+make -C tmp/distcheck/srccheck clean
|
||||
$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)
|
||||
$(Q)rm -Rf tmp/distcheck/srccheck
|
||||
|
||||
|
||||
######################################################################
|
||||
# Unix binary installer tarballs
|
||||
######################################################################
|
||||
|
||||
define DEF_START_INSTALLER
|
||||
dist-install-dir-$(1)-%: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
|
||||
dist-install-dir-$(1)-%: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
|
||||
dist-install-dir-$(1)-%: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
|
||||
dist-install-dir-$(1)-%: PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
|
||||
dist-install-dir-$(1)-%: PREPARE_CLEAN=true
|
||||
|
||||
$$(eval $$(call DEF_PREPARE,dir-$(1)))
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET),\
|
||||
$(eval $(call DEF_START_INSTALLER,$(target))))
|
||||
|
||||
define DEF_INSTALLER
|
||||
|
||||
dist-install-dir-$(1)-host: PREPARE_HOST=$(1)
|
||||
dist-install-dir-$(1)-host: PREPARE_TARGETS=$(2)
|
||||
dist-install-dir-$(1)-host: PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)-image
|
||||
dist-install-dir-$(1)-host: prepare-base-dir-$(1)-host docs
|
||||
$$(Q)mkdir -p $$(PREPARE_DEST_DIR)/share/doc/rust
|
||||
$$(Q)$$(PREPARE_MAN_CMD) $$(S)COPYRIGHT $$(PREPARE_DEST_DIR)/share/doc/rust
|
||||
$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)/share/doc/rust
|
||||
$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-MIT $$(PREPARE_DEST_DIR)/share/doc/rust
|
||||
$$(Q)$$(PREPARE_MAN_CMD) $$(S)README.md $$(PREPARE_DEST_DIR)/share/doc/rust
|
||||
|
||||
prepare-overlay-$(1):
|
||||
$$(Q)rm -Rf tmp/dist/$$(PKG_NAME)-$(1)-overlay
|
||||
$$(Q)mkdir -p tmp/dist/$$(PKG_NAME)-$(1)-overlay
|
||||
$$(Q)cp $$(S)COPYRIGHT tmp/dist/$$(PKG_NAME)-$(1)-overlay/
|
||||
$$(Q)cp $$(S)LICENSE-APACHE tmp/dist/$$(PKG_NAME)-$(1)-overlay/
|
||||
$$(Q)cp $$(S)LICENSE-MIT tmp/dist/$$(PKG_NAME)-$(1)-overlay/
|
||||
$$(Q)cp $$(S)README.md tmp/dist/$$(PKG_NAME)-$(1)-overlay/
|
||||
# This tiny morsel of metadata is used by rust-packaging
|
||||
$$(Q)echo "$(CFG_VERSION)" > tmp/dist/$$(PKG_NAME)-$(1)-overlay/version
|
||||
|
||||
dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)-host prepare-overlay-$(1)
|
||||
@$(call E, build: $$@)
|
||||
# On a MinGW target we've got a few runtime DLL dependencies that we need
|
||||
# to include. THe first argument to `make-win-dist` is where to put these DLLs
|
||||
# (the image we're creating) and the second argument is a junk directory to
|
||||
# ignore all the other MinGW stuff the script creates.
|
||||
ifeq ($$(findstring pc-windows-gnu,$(1)),pc-windows-gnu)
|
||||
$$(Q)rm -Rf tmp/dist/win-rust-gcc-$(1)
|
||||
$$(Q)$$(CFG_PYTHON) $$(S)src/etc/make-win-dist.py \
|
||||
tmp/dist/$$(PKG_NAME)-$(1)-image \
|
||||
tmp/dist/win-rust-gcc-$(1) $(1)
|
||||
endif
|
||||
# On 32-bit MinGW we're always including a DLL which needs some extra licenses
|
||||
# to distribute. On 64-bit MinGW we don't actually distribute anything requiring
|
||||
# us to distribute a license but it's likely that the install will *also*
|
||||
# include the rust-mingw package down below, which also need licenses, so to be
|
||||
# safe we just inlude it here in all MinGW packages.
|
||||
ifdef CFG_WINDOWSY_$(1)
|
||||
ifeq ($$(findstring $(1),gnu),gnu)
|
||||
$$(Q)cp -r $$(S)src/etc/third-party \
|
||||
tmp/dist/$$(PKG_NAME)-$(1)-image/share/doc/
|
||||
endif
|
||||
endif
|
||||
$$(Q)$$(S)src/rust-installer/gen-installer.sh \
|
||||
--product-name=Rust \
|
||||
--rel-manifest-dir=rustlib \
|
||||
--success-message=Rust-is-ready-to-roll. \
|
||||
--image-dir=tmp/dist/$$(PKG_NAME)-$(1)-image \
|
||||
--work-dir=tmp/dist \
|
||||
--output-dir=dist \
|
||||
--non-installed-overlay=tmp/dist/$$(PKG_NAME)-$(1)-overlay \
|
||||
--package-name=$$(PKG_NAME)-$(1) \
|
||||
--component-name=rustc \
|
||||
--legacy-manifest-dirs=rustlib,cargo
|
||||
$$(Q)rm -R tmp/dist/$$(PKG_NAME)-$(1)-image
|
||||
|
||||
dist-doc-install-dir-$(1): docs
|
||||
$$(Q)mkdir -p tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust
|
||||
$$(Q)cp -r doc tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust/html
|
||||
|
||||
dist/$$(DOC_PKG_NAME)-$(1).tar.gz: dist-doc-install-dir-$(1)
|
||||
@$(call E, build: $$@)
|
||||
$$(Q)$$(S)src/rust-installer/gen-installer.sh \
|
||||
--product-name=Rust-Documentation \
|
||||
--rel-manifest-dir=rustlib \
|
||||
--success-message=Rust-documentation-is-installed. \
|
||||
--image-dir=tmp/dist/$$(DOC_PKG_NAME)-$(1)-image \
|
||||
--work-dir=tmp/dist \
|
||||
--output-dir=dist \
|
||||
--package-name=$$(DOC_PKG_NAME)-$(1) \
|
||||
--component-name=rust-docs \
|
||||
--legacy-manifest-dirs=rustlib,cargo \
|
||||
--bulk-dirs=share/doc/rust/html
|
||||
$$(Q)rm -R tmp/dist/$$(DOC_PKG_NAME)-$(1)-image
|
||||
|
||||
# Creates the rust-mingw package, and the first argument to make-win-dist is a
|
||||
# "temporary directory" which is just thrown away (this contains the runtime
|
||||
# DLLs included in the rustc package above) and the second argument is where to
|
||||
# place all the MinGW components (which is what we want).
|
||||
dist-mingw-install-dir-$(1):
|
||||
$$(Q)mkdir -p tmp/dist/rust-mingw-tmp-$(1)-image
|
||||
$$(Q)rm -Rf tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image
|
||||
$$(Q)$$(CFG_PYTHON) $$(S)src/etc/make-win-dist.py \
|
||||
tmp/dist/rust-mingw-tmp-$(1)-image \
|
||||
tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image $(1)
|
||||
|
||||
dist/$$(MINGW_PKG_NAME)-$(1).tar.gz: dist-mingw-install-dir-$(1)
|
||||
@$(call E, build: $$@)
|
||||
$$(Q)$$(S)src/rust-installer/gen-installer.sh \
|
||||
--product-name=Rust-MinGW \
|
||||
--rel-manifest-dir=rustlib \
|
||||
--success-message=Rust-MinGW-is-installed. \
|
||||
--image-dir=tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image \
|
||||
--work-dir=tmp/dist \
|
||||
--output-dir=dist \
|
||||
--package-name=$$(MINGW_PKG_NAME)-$(1) \
|
||||
--component-name=rust-mingw \
|
||||
--legacy-manifest-dirs=rustlib,cargo
|
||||
$$(Q)rm -R tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image
|
||||
|
||||
endef
|
||||
|
||||
# $(1) - host
|
||||
# $(2) - target
|
||||
define DEF_INSTALLER_TARGETS
|
||||
|
||||
dist-install-dir-$(2)-target: PREPARE_HOST=$(1)
|
||||
dist-install-dir-$(2)-target: PREPARE_TARGETS=$(2)
|
||||
dist-install-dir-$(2)-target: PREPARE_DEST_DIR=tmp/dist/$$(STD_PKG_NAME)-$(2)-image
|
||||
dist-install-dir-$(2)-target: prepare-base-dir-$(2)-target
|
||||
|
||||
dist/$$(STD_PKG_NAME)-$(2).tar.gz: dist-install-dir-$(2)-target
|
||||
@$$(call E, build: $$@)
|
||||
$$(Q)$$(S)src/rust-installer/gen-installer.sh \
|
||||
--product-name=Rust \
|
||||
--rel-manifest-dir=rustlib \
|
||||
--success-message=std-is-standing-at-the-ready. \
|
||||
--image-dir=tmp/dist/$$(STD_PKG_NAME)-$(2)-image \
|
||||
--work-dir=tmp/dist \
|
||||
--output-dir=dist \
|
||||
--package-name=$$(STD_PKG_NAME)-$(2) \
|
||||
--component-name=rust-std-$(2) \
|
||||
--legacy-manifest-dirs=rustlib,cargo
|
||||
$$(Q)rm -R tmp/dist/$$(STD_PKG_NAME)-$(2)-image
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST),\
|
||||
$(eval $(call DEF_INSTALLER,$(host))))
|
||||
|
||||
dist/$(SRC_PKG_NAME).tar.gz: tmp/dist/$(SRC_PKG_NAME)-image
|
||||
@$(call E, build: $@)
|
||||
$(Q)$(S)src/rust-installer/gen-installer.sh \
|
||||
--product-name=Rust \
|
||||
--rel-manifest-dir=rustlib \
|
||||
--success-message=Awesome-Source. \
|
||||
--image-dir=tmp/dist/$(SRC_PKG_NAME)-image \
|
||||
--work-dir=tmp/dist \
|
||||
--output-dir=dist \
|
||||
--package-name=$(SRC_PKG_NAME) \
|
||||
--component-name=rust-src \
|
||||
--legacy-manifest-dirs=rustlib,cargo
|
||||
|
||||
# When generating packages for the standard library, we've actually got a lot of
|
||||
# artifacts to choose from. Each of the CFG_HOST compilers will have a copy of
|
||||
# the standard library for each CFG_TARGET, but we only want to generate one
|
||||
# standard library package. As a result, for each entry in CFG_TARGET we need to
|
||||
# pick a CFG_HOST to get the standard library from.
|
||||
#
|
||||
# In theory it doesn't actually matter what host we choose as it should be the
|
||||
# case that all hosts produce the same set of libraries for a target (regardless
|
||||
# of the host itself). Currently there is a bug in the compiler, however, which
|
||||
# means this is not the case (see #29228 and #29235). To solve the first of
|
||||
# those bugs, we prefer to select a standard library from the host it was
|
||||
# generated from, allowing plugins to work in more situations.
|
||||
#
|
||||
# For all CFG_TARGET entries in CFG_HOST, however, we just pick CFG_BUILD as the
|
||||
# host we slurp up a standard library from.
|
||||
$(foreach host,$(CFG_HOST),\
|
||||
$(eval $(call DEF_INSTALLER_TARGETS,$(host),$(host))))
|
||||
$(foreach target,$(filter-out $(CFG_HOST),$(CFG_TARGET)),\
|
||||
$(eval $(call DEF_INSTALLER_TARGETS,$(CFG_BUILD),$(target))))
|
||||
|
||||
ifdef CFG_WINDOWSY_$(CFG_BUILD)
|
||||
define BUILD_MINGW_TARBALL
|
||||
ifeq ($$(findstring gnu,$(1)),gnu)
|
||||
MAYBE_MINGW_TARBALLS += dist/$(MINGW_PKG_NAME)-$(1).tar.gz
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST),\
|
||||
$(eval $(call BUILD_MINGW_TARBALL,$(host))))
|
||||
endif
|
||||
|
||||
ifeq ($(CFG_DISABLE_DOCS),)
|
||||
MAYBE_DOC_TARBALLS=$(foreach host,$(CFG_HOST),dist/$(DOC_PKG_NAME)-$(host).tar.gz)
|
||||
endif
|
||||
|
||||
dist-tar-bins: \
|
||||
$(foreach host,$(CFG_HOST),dist/$(PKG_NAME)-$(host).tar.gz) \
|
||||
$(foreach target,$(CFG_TARGET),dist/$(STD_PKG_NAME)-$(target).tar.gz) \
|
||||
$(MAYBE_DOC_TARBALLS) $(MAYBE_MINGW_TARBALLS)
|
||||
|
||||
# Just try to run the compiler for the build host
|
||||
distcheck-tar-bins: dist-tar-bins
|
||||
@$(call E, checking binary tarball)
|
||||
$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
|
||||
$(Q)rm -Rf tmp/distcheck/tarbininstall
|
||||
$(Q)mkdir -p tmp/distcheck
|
||||
$(Q)cd tmp/distcheck && tar -xzf ../../dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz
|
||||
$(Q)mkdir -p tmp/distcheck/tarbininstall
|
||||
$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall
|
||||
$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall --uninstall
|
||||
$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
|
||||
$(Q)rm -Rf tmp/distcheck/tarbininstall
|
||||
|
||||
######################################################################
|
||||
# Docs
|
||||
######################################################################
|
||||
|
||||
# Just copy the docs to a folder under dist with the appropriate name
|
||||
# for uploading to S3
|
||||
dist-docs: docs
|
||||
$(Q) rm -Rf dist/doc
|
||||
$(Q) mkdir -p dist/doc/
|
||||
$(Q) cp -r doc dist/doc/$(CFG_PACKAGE_VERS)
|
||||
|
||||
distcheck-docs: dist-docs
|
||||
|
||||
######################################################################
|
||||
# Primary targets (dist, distcheck)
|
||||
######################################################################
|
||||
|
||||
MAYBE_DIST_TAR_SRC=dist-tar-src dist/$(SRC_PKG_NAME).tar.gz
|
||||
MAYBE_DISTCHECK_TAR_SRC=distcheck-tar-src dist/$(SRC_PKG_NAME).tar.gz
|
||||
|
||||
# FIXME #13224: On OS X don't produce tarballs simply because --exclude-vcs don't work.
|
||||
# This is a huge hack because I just don't have time to figure out another solution.
|
||||
ifeq ($(CFG_OSTYPE), apple-darwin)
|
||||
MAYBE_DIST_TAR_SRC=
|
||||
MAYBE_DISTCHECK_TAR_SRC=
|
||||
endif
|
||||
|
||||
# Don't bother with source tarballs on windows just because we historically haven't.
|
||||
ifeq ($(CFG_OSTYPE), pc-windows-gnu)
|
||||
MAYBE_DIST_TAR_SRC=
|
||||
MAYBE_DISTCHECK_TAR_SRC=
|
||||
endif
|
||||
|
||||
ifneq ($(CFG_DISABLE_DOCS),)
|
||||
MAYBE_DIST_DOCS=
|
||||
MAYBE_DISTCHECK_DOCS=
|
||||
else
|
||||
MAYBE_DIST_DOCS=dist-docs
|
||||
MAYBE_DISTCHECK_DOCS=distcheck-docs
|
||||
endif
|
||||
|
||||
dist: $(MAYBE_DIST_TAR_SRC) dist-tar-bins $(MAYBE_DIST_DOCS)
|
||||
|
||||
distcheck: $(MAYBE_DISTCHECK_TAR_SRC) distcheck-tar-bins $(MAYBE_DISTCHECK_DOCS)
|
||||
$(Q)rm -Rf tmp/distcheck
|
||||
@echo
|
||||
@echo -----------------------------------------------
|
||||
@echo "Rust ready for distribution (see ./dist)"
|
||||
@echo -----------------------------------------------
|
||||
|
||||
.PHONY: dist distcheck
|
||||
222
mk/docs.mk
222
mk/docs.mk
@ -1,222 +0,0 @@
|
||||
# Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# The various pieces of standalone documentation.
|
||||
#
|
||||
# The DOCS variable is their names (with no file extension).
|
||||
#
|
||||
# RUSTDOC_FLAGS_xyz variables are extra arguments to pass to the
|
||||
# rustdoc invocation for xyz.
|
||||
#
|
||||
# RUSTDOC_DEPS_xyz are extra dependencies for the rustdoc invocation
|
||||
# on xyz.
|
||||
#
|
||||
# L10N_LANGS are the languages for which the docs have been
|
||||
# translated.
|
||||
######################################################################
|
||||
DOCS := index \
|
||||
complement-lang-faq complement-design-faq complement-project-faq \
|
||||
rustdoc reference grammar
|
||||
|
||||
# Legacy guides, preserved for a while to reduce the number of 404s
|
||||
DOCS += guide-crates guide-error-handling guide-ffi guide-macros guide \
|
||||
guide-ownership guide-plugins guide-pointers guide-strings guide-tasks \
|
||||
guide-testing tutorial intro
|
||||
|
||||
|
||||
RUSTDOC_DEPS_reference := doc/full-toc.inc
|
||||
RUSTDOC_FLAGS_reference := --html-in-header=doc/full-toc.inc
|
||||
|
||||
L10N_LANGS := ja
|
||||
|
||||
# Generally no need to edit below here.
|
||||
|
||||
# The options are passed to the documentation generators.
|
||||
RUSTDOC_HTML_OPTS_NO_CSS = --html-before-content=doc/version_info.html \
|
||||
--html-in-header=doc/favicon.inc \
|
||||
--html-after-content=doc/footer.inc \
|
||||
--markdown-playground-url='https://play.rust-lang.org/'
|
||||
|
||||
RUSTDOC_HTML_OPTS = $(RUSTDOC_HTML_OPTS_NO_CSS) --markdown-css rust.css
|
||||
|
||||
# The rustdoc executable...
|
||||
RUSTDOC_EXE = $(HBIN2_H_$(CFG_BUILD))/rustdoc$(X_$(CFG_BUILD))
|
||||
# ...with rpath included in case --disable-rpath was provided to
|
||||
# ./configure
|
||||
RUSTDOC = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(RUSTDOC_EXE)
|
||||
|
||||
# The rustbook executable...
|
||||
RUSTBOOK_EXE = $(HBIN2_H_$(CFG_BUILD))/rustbook$(X_$(CFG_BUILD))
|
||||
# ...with rpath included in case --disable-rpath was provided to
|
||||
# ./configure
|
||||
RUSTBOOK = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(RUSTBOOK_EXE)
|
||||
|
||||
# The error_index_generator executable...
|
||||
ERR_IDX_GEN_EXE = $(HBIN2_H_$(CFG_BUILD))/error_index_generator$(X_$(CFG_BUILD))
|
||||
ERR_IDX_GEN = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE)
|
||||
ERR_IDX_GEN_MD = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE) markdown
|
||||
|
||||
D := $(S)src/doc
|
||||
|
||||
DOC_TARGETS := book nomicon error-index
|
||||
COMPILER_DOC_TARGETS :=
|
||||
DOC_L10N_TARGETS :=
|
||||
|
||||
# If NO_REBUILD is set then break the dependencies on rustdoc so we
|
||||
# build the documentation without having to rebuild rustdoc.
|
||||
ifeq ($(NO_REBUILD),)
|
||||
HTML_DEPS := $(RUSTDOC_EXE)
|
||||
else
|
||||
HTML_DEPS :=
|
||||
endif
|
||||
|
||||
######################################################################
|
||||
# Rust version
|
||||
######################################################################
|
||||
|
||||
HTML_DEPS += doc/version_info.html
|
||||
doc/version_info.html: $(D)/version_info.html.template $(MKFILE_DEPS) \
|
||||
$(wildcard $(D)/*.*) | doc/
|
||||
@$(call E, version-info: $@)
|
||||
$(Q)sed -e "s/VERSION/$(CFG_RELEASE)/; \
|
||||
s/SHORT_HASH/$(CFG_SHORT_VER_HASH)/; \
|
||||
s/STAMP/$(CFG_VER_HASH)/;" $< >$@
|
||||
|
||||
GENERATED += doc/version_info.html
|
||||
|
||||
######################################################################
|
||||
# Docs from rustdoc
|
||||
######################################################################
|
||||
|
||||
doc/:
|
||||
@mkdir -p $@
|
||||
|
||||
HTML_DEPS += doc/rust.css
|
||||
doc/rust.css: $(D)/rust.css | doc/
|
||||
@$(call E, cp: $@)
|
||||
$(Q)cp -PRp $< $@ 2> /dev/null
|
||||
|
||||
HTML_DEPS += doc/favicon.inc
|
||||
doc/favicon.inc: $(D)/favicon.inc | doc/
|
||||
@$(call E, cp: $@)
|
||||
$(Q)cp -PRp $< $@ 2> /dev/null
|
||||
|
||||
doc/full-toc.inc: $(D)/full-toc.inc | doc/
|
||||
@$(call E, cp: $@)
|
||||
$(Q)cp -PRp $< $@ 2> /dev/null
|
||||
|
||||
HTML_DEPS += doc/footer.inc
|
||||
doc/footer.inc: $(D)/footer.inc | doc/
|
||||
@$(call E, cp: $@)
|
||||
$(Q)cp -PRp $< $@ 2> /dev/null
|
||||
|
||||
# The (english) documentation for each doc item.
|
||||
DOC_TARGETS += doc/not_found.html
|
||||
doc/not_found.html: $(D)/not_found.md $(HTML_DEPS) | doc/
|
||||
@$(call E, rustdoc: $@)
|
||||
$(Q)$(RUSTDOC) $(RUSTDOC_HTML_OPTS_NO_CSS) \
|
||||
--markdown-no-toc \
|
||||
--markdown-css https://doc.rust-lang.org/rust.css $<
|
||||
|
||||
define DEF_DOC
|
||||
|
||||
# HTML (rustdoc)
|
||||
DOC_TARGETS += doc/$(1).html
|
||||
doc/$(1).html: $$(D)/$(1).md $$(HTML_DEPS) $$(RUSTDOC_DEPS_$(1)) | doc/
|
||||
@$$(call E, rustdoc: $$@)
|
||||
$$(Q)$$(RUSTDOC) $$(RUSTDOC_HTML_OPTS) $$(RUSTDOC_FLAGS_$(1)) $$<
|
||||
|
||||
endef
|
||||
|
||||
$(foreach docname,$(DOCS),$(eval $(call DEF_DOC,$(docname))))
|
||||
|
||||
|
||||
######################################################################
|
||||
# Rustdoc (libstd/extra)
|
||||
######################################################################
|
||||
|
||||
|
||||
# The library documenting macro
|
||||
#
|
||||
# $(1) - The crate name (std/extra)
|
||||
#
|
||||
# Passes --cfg stage2 to rustdoc because it uses the stage2 librustc.
|
||||
define DEF_LIB_DOC
|
||||
|
||||
# If NO_REBUILD is set then break the dependencies on rustdoc so we
|
||||
# build crate documentation without having to rebuild rustdoc.
|
||||
ifeq ($(NO_REBUILD),)
|
||||
LIB_DOC_DEP_$(1) = \
|
||||
$$(CRATEFILE_$(1)) \
|
||||
$$(RSINPUTS_$(1)) \
|
||||
$$(RUSTDOC_EXE) \
|
||||
$$(foreach dep,$$(RUST_DEPS_$(1)_T_$(CFG_BUILD)), \
|
||||
$$(TLIB2_T_$(CFG_BUILD)_H_$(CFG_BUILD))/stamp.$$(dep)) \
|
||||
$$(foreach dep,$$(filter $$(DOC_CRATES), $$(RUST_DEPS_$(1)_T_$(CFG_BUILD))), \
|
||||
doc/$$(dep)/)
|
||||
else
|
||||
LIB_DOC_DEP_$(1) = $$(CRATEFILE_$(1)) $$(RSINPUTS_$(1))
|
||||
endif
|
||||
|
||||
doc/$(1)/:
|
||||
$$(Q)mkdir -p $$@
|
||||
|
||||
doc/$(1)/index.html: CFG_COMPILER_HOST_TRIPLE = $(CFG_TARGET)
|
||||
doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
|
||||
@$$(call E, rustdoc: $$@)
|
||||
$$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(CFG_BUILD)) \
|
||||
$$(RUSTDOC) --cfg dox --cfg stage2 $$(RUSTFLAGS_$(1)) $$<
|
||||
endef
|
||||
|
||||
$(foreach crate,$(CRATES),$(eval $(call DEF_LIB_DOC,$(crate))))
|
||||
|
||||
COMPILER_DOC_TARGETS := $(CRATES:%=doc/%/index.html)
|
||||
ifdef CFG_ENABLE_COMPILER_DOCS
|
||||
DOC_TARGETS += $(COMPILER_DOC_TARGETS)
|
||||
else
|
||||
DOC_TARGETS += $(DOC_CRATES:%=doc/%/index.html)
|
||||
endif
|
||||
|
||||
ifdef CFG_DISABLE_DOCS
|
||||
$(info cfg: disabling doc build (CFG_DISABLE_DOCS))
|
||||
DOC_TARGETS :=
|
||||
COMPILER_DOC_TARGETS :=
|
||||
endif
|
||||
|
||||
docs: $(DOC_TARGETS)
|
||||
doc: docs
|
||||
compiler-docs: $(COMPILER_DOC_TARGETS)
|
||||
|
||||
book: doc/book/index.html
|
||||
|
||||
doc/book/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/book/*.md) | doc/
|
||||
@$(call E, rustbook: $@)
|
||||
$(Q)rm -rf doc/book
|
||||
$(Q)$(RUSTBOOK) build $(S)src/doc/book doc/book
|
||||
|
||||
nomicon: doc/nomicon/index.html
|
||||
|
||||
doc/nomicon/index.html: $(RUSTBOOK_EXE) $(wildcard $(S)/src/doc/nomicon/*.md) | doc/
|
||||
@$(call E, rustbook: $@)
|
||||
$(Q)rm -rf doc/nomicon
|
||||
$(Q)$(RUSTBOOK) build $(S)src/doc/nomicon doc/nomicon
|
||||
|
||||
error-index: doc/error-index.html
|
||||
|
||||
# Metadata used to generate the index is created as a side effect of
|
||||
# the build so this depends on every crate being up to date.
|
||||
doc/error-index.html: $(ERR_IDX_GEN_EXE) $(CSREQ$(2)_T_$(CFG_BUILD)_H_$(CFG_BUILD)) | doc/
|
||||
$(Q)$(call E, error_index_generator: $@)
|
||||
$(Q)$(ERR_IDX_GEN)
|
||||
|
||||
doc/error-index.md: $(ERR_IDX_GEN_EXE) $(CSREQ$(2)_T_$(CFG_BUILD)_H_$(CFG_BUILD)) | doc/
|
||||
$(Q)$(call E, error_index_generator: $@)
|
||||
$(Q)$(ERR_IDX_GEN_MD)
|
||||
117
mk/grammar.mk
117
mk/grammar.mk
@ -1,117 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
BG = $(CFG_BUILD_DIR)/grammar/
|
||||
SG = $(S)src/grammar/
|
||||
B = $(CFG_BUILD_DIR)/$(CFG_BUILD)/stage2/
|
||||
L = $(B)lib/rustlib/$(CFG_BUILD)/lib
|
||||
LD = $(CFG_BUILD)/stage2/lib/rustlib/$(CFG_BUILD)/lib/
|
||||
RUSTC = $(STAGE2_T_$(CFG_BUILD)_H_$(CFG_BUILD))
|
||||
ifeq ($(CFG_OSTYPE),apple-darwin)
|
||||
FLEX_LDFLAGS=-ll
|
||||
else
|
||||
FLEX_LDFLAGS=-lfl
|
||||
endif
|
||||
|
||||
# Run the reference lexer against libsyntax and compare the tokens and spans.
|
||||
# If "// ignore-lexer-test" is present in the file, it will be ignored.
|
||||
#
|
||||
# $(1) is the file to test.
|
||||
define LEXER_TEST
|
||||
grep "// ignore-lexer-test" $(1) ; \
|
||||
if [ $$? -eq 1 ]; then \
|
||||
CLASSPATH=$(B)grammar $(CFG_GRUN) RustLexer tokens -tokens < $(1) \
|
||||
| $(B)grammar/verify $(1) ; \
|
||||
fi
|
||||
endef
|
||||
|
||||
$(BG):
|
||||
$(Q)mkdir -p $(BG)
|
||||
|
||||
$(BG)RustLexer.class: $(BG) $(SG)RustLexer.g4
|
||||
$(Q)$(CFG_ANTLR4) -o $(BG) $(SG)RustLexer.g4
|
||||
$(Q)$(CFG_JAVAC) -d $(BG) -classpath $(CFG_ANTLR4_JAR) $(BG)RustLexer.java
|
||||
|
||||
check-build-lexer-verifier: $(BG)verify
|
||||
|
||||
ifeq ($(NO_REBUILD),)
|
||||
VERIFY_DEPS := rustc-stage2-H-$(CFG_BUILD) $(LD)stamp.rustc
|
||||
else
|
||||
VERIFY_DEPS :=
|
||||
endif
|
||||
|
||||
$(BG)verify: $(BG) $(SG)verify.rs $(VERIFY_DEPS)
|
||||
$(Q)$(RUSTC) --out-dir $(BG) -L $(L) $(SG)verify.rs
|
||||
|
||||
ifdef CFG_JAVAC
|
||||
ifdef CFG_ANTLR4
|
||||
ifdef CFG_GRUN
|
||||
check-lexer: $(BG) $(BG)RustLexer.class check-build-lexer-verifier
|
||||
$(info Verifying libsyntax against the reference lexer ...)
|
||||
$(Q)$(SG)check.sh $(S) "$(BG)" \
|
||||
"$(CFG_GRUN)" "$(BG)verify" "$(BG)RustLexer.tokens"
|
||||
else
|
||||
$(info cfg: lexer tooling not available, skipping lexer test...)
|
||||
check-lexer:
|
||||
|
||||
endif
|
||||
else
|
||||
$(info cfg: lexer tooling not available, skipping lexer test...)
|
||||
check-lexer:
|
||||
|
||||
endif
|
||||
else
|
||||
$(info cfg: lexer tooling not available, skipping lexer test...)
|
||||
check-lexer:
|
||||
|
||||
endif
|
||||
|
||||
$(BG)lex.yy.c: $(SG)lexer.l $(BG)
|
||||
@$(call E, flex: $@)
|
||||
$(Q)$(CFG_FLEX) -o $@ $<
|
||||
|
||||
$(BG)lexer-lalr.o: $(BG)lex.yy.c $(BG)parser-lalr.tab.h
|
||||
@$(call E, cc: $@)
|
||||
$(Q)$(CFG_CC) -include $(BG)parser-lalr.tab.h -c -o $@ $<
|
||||
|
||||
$(BG)parser-lalr.tab.c $(BG)parser-lalr.tab.h: $(SG)parser-lalr.y
|
||||
@$(call E, bison: $@)
|
||||
$(Q)$(CFG_BISON) $< --output=$(BG)parser-lalr.tab.c --defines=$(BG)parser-lalr.tab.h \
|
||||
--name-prefix=rs --warnings=error=all
|
||||
|
||||
$(BG)parser-lalr.o: $(BG)parser-lalr.tab.c
|
||||
@$(call E, cc: $@)
|
||||
$(Q)$(CFG_CC) -c -o $@ $<
|
||||
|
||||
$(BG)parser-lalr-main.o: $(SG)parser-lalr-main.c
|
||||
@$(call E, cc: $@)
|
||||
$(Q)$(CFG_CC) -std=c99 -c -o $@ $<
|
||||
|
||||
$(BG)parser-lalr: $(BG)parser-lalr.o $(BG)parser-lalr-main.o $(BG)lexer-lalr.o
|
||||
@$(call E, cc: $@)
|
||||
$(Q)$(CFG_CC) -o $@ $^ $(FLEX_LDFLAGS)
|
||||
|
||||
|
||||
ifdef CFG_FLEX
|
||||
ifdef CFG_BISON
|
||||
check-grammar: $(BG) $(BG)parser-lalr
|
||||
$(info Verifying grammar ...)
|
||||
$(SG)testparser.py -p $(BG)parser-lalr -s $(S)src
|
||||
|
||||
else
|
||||
$(info cfg: bison not available, skipping parser test...)
|
||||
check-grammar:
|
||||
|
||||
endif
|
||||
else
|
||||
$(info cfg: flex not available, skipping parser test...)
|
||||
check-grammar:
|
||||
|
||||
endif
|
||||
84
mk/host.mk
84
mk/host.mk
@ -1,84 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# Generic rule for copying any target crate to a host crate. This rule will also
|
||||
# promote any dependent rust crates up to their host locations as well
|
||||
#
|
||||
# $(1) - the stage to copy from
|
||||
# $(2) - the stage to copy to
|
||||
# $(3) - the host triple
|
||||
# $(4) - the target triple (same as $(3))
|
||||
# $(5) - the name of the crate being processed
|
||||
define CP_HOST_STAGE_N_CRATE
|
||||
|
||||
ifeq ($$(ONLY_RLIB_$(5)),)
|
||||
$$(HLIB$(2)_H_$(4))/stamp.$(5): \
|
||||
$$(TLIB$(1)_T_$(3)_H_$(4))/stamp.$(5) \
|
||||
$$(RUST_DEPS_$(5)_T_$(3):%=$$(HLIB$(2)_H_$(4))/stamp.%) \
|
||||
| $$(HLIB$(2)_H_$(4))/
|
||||
@$$(call E, cp: $$(@D)/lib$(5))
|
||||
$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_LIB_GLOB_$(3),$(5)))
|
||||
$$(Q)cp $$< $$@
|
||||
$$(Q)cp -R $$(TLIB$(1)_T_$(3)_H_$(4))/$$(call CFG_LIB_GLOB_$(3),$(5)) \
|
||||
$$(HLIB$(2)_H_$(4))
|
||||
$$(call LIST_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_LIB_GLOB_$(3),$(5)))
|
||||
else
|
||||
$$(HLIB$(2)_H_$(4))/stamp.$(5):
|
||||
$$(Q)touch $$@
|
||||
endif
|
||||
|
||||
endef
|
||||
|
||||
# Same as the above macro, but for tools instead of crates
|
||||
define CP_HOST_STAGE_N_TOOL
|
||||
|
||||
$$(HBIN$(2)_H_$(4))/$(5)$$(X_$(3)): \
|
||||
$$(TBIN$(1)_T_$(3)_H_$(4))/$(5)$$(X_$(3)) \
|
||||
$$(TOOL_DEPS_$(5):%=$$(HLIB$(2)_H_$(4))/stamp.%) \
|
||||
| $$(HBIN$(2)_H_$(4))/
|
||||
@$$(call E, cp: $$@)
|
||||
$$(Q)cp $$< $$@
|
||||
|
||||
endef
|
||||
|
||||
|
||||
# Miscellaneous rules for just making a few directories.
|
||||
#
|
||||
# $(1) - the stage to copy from
|
||||
# $(2) - the stage to copy to
|
||||
# $(3) - the target triple
|
||||
# $(4) - the host triple (same as $(3))
|
||||
define CP_HOST_STAGE_N
|
||||
|
||||
ifneq ($(CFG_LIBDIR_RELATIVE),bin)
|
||||
$$(HLIB$(2)_H_$(4))/:
|
||||
@mkdir -p $$@
|
||||
endif
|
||||
|
||||
endef
|
||||
|
||||
$(foreach t,$(CFG_HOST), \
|
||||
$(eval $(call CP_HOST_STAGE_N,0,1,$(t),$(t))) \
|
||||
$(eval $(call CP_HOST_STAGE_N,1,2,$(t),$(t))) \
|
||||
$(eval $(call CP_HOST_STAGE_N,2,3,$(t),$(t))))
|
||||
|
||||
$(foreach crate,$(CRATES), \
|
||||
$(foreach t,$(CFG_HOST), \
|
||||
$(eval $(call CP_HOST_STAGE_N_CRATE,0,1,$(t),$(t),$(crate))) \
|
||||
$(eval $(call CP_HOST_STAGE_N_CRATE,1,2,$(t),$(t),$(crate))) \
|
||||
$(eval $(call CP_HOST_STAGE_N_CRATE,2,3,$(t),$(t),$(crate)))))
|
||||
|
||||
$(foreach tool,$(TOOLS), \
|
||||
$(foreach t,$(CFG_HOST), \
|
||||
$(eval $(call CP_HOST_STAGE_N_TOOL,0,1,$(t),$(t),$(tool))) \
|
||||
$(eval $(call CP_HOST_STAGE_N_TOOL,1,2,$(t),$(t),$(tool))) \
|
||||
$(eval $(call CP_HOST_STAGE_N_TOOL,2,3,$(t),$(t),$(tool)))))
|
||||
138
mk/install.mk
138
mk/install.mk
@ -1,138 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
RUN_INSTALLER = cd tmp/empty_dir && \
|
||||
sh ../../tmp/dist/$(1)/install.sh \
|
||||
--prefix="$(DESTDIR)$(CFG_PREFIX)" \
|
||||
--libdir="$(DESTDIR)$(CFG_LIBDIR)" \
|
||||
--mandir="$(DESTDIR)$(CFG_MANDIR)" \
|
||||
--docdir="$(DESTDIR)$(CFG_DOCDIR)"
|
||||
|
||||
install:
|
||||
ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
|
||||
# Build the dist as the original user
|
||||
$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_install
|
||||
else
|
||||
$(Q)$(MAKE) prepare_install
|
||||
endif
|
||||
ifeq ($(CFG_DISABLE_DOCS),)
|
||||
$(Q)$(call RUN_INSTALLER,$(DOC_PKG_NAME)-$(CFG_BUILD)) --disable-ldconfig
|
||||
endif
|
||||
$(Q)$(foreach target,$(CFG_TARGET),\
|
||||
($(call RUN_INSTALLER,$(STD_PKG_NAME)-$(target)) --disable-ldconfig);)
|
||||
$(Q)$(call RUN_INSTALLER,$(PKG_NAME)-$(CFG_BUILD))
|
||||
# Remove tmp files because it's a decent amount of disk space
|
||||
$(Q)rm -R tmp/dist
|
||||
|
||||
prepare_install: dist-tar-bins | tmp/empty_dir
|
||||
|
||||
uninstall:
|
||||
ifeq (root user, $(USER) $(patsubst %,user,$(SUDO_USER)))
|
||||
# Build the dist as the original user
|
||||
$(Q)sudo -u "$$SUDO_USER" $(MAKE) prepare_uninstall
|
||||
else
|
||||
$(Q)$(MAKE) prepare_uninstall
|
||||
endif
|
||||
ifeq ($(CFG_DISABLE_DOCS),)
|
||||
$(Q)$(call RUN_INSTALLER,$(DOC_PKG_NAME)-$(CFG_BUILD)) --uninstall
|
||||
endif
|
||||
$(Q)$(call RUN_INSTALLER,$(PKG_NAME)-$(CFG_BUILD)) --uninstall
|
||||
$(Q)$(foreach target,$(CFG_TARGET),\
|
||||
($(call RUN_INSTALLER,$(STD_PKG_NAME)-$(target)) --uninstall);)
|
||||
# Remove tmp files because it's a decent amount of disk space
|
||||
$(Q)rm -R tmp/dist
|
||||
|
||||
prepare_uninstall: dist-tar-bins | tmp/empty_dir
|
||||
|
||||
.PHONY: install prepare_install uninstall prepare_uninstall
|
||||
|
||||
tmp/empty_dir:
|
||||
mkdir -p $@
|
||||
|
||||
######################################################################
|
||||
# Android remote installation
|
||||
######################################################################
|
||||
|
||||
# Android runtime setup
|
||||
# FIXME: This probably belongs somewhere else
|
||||
|
||||
# target platform specific variables for android
|
||||
define DEF_ADB_DEVICE_STATUS
|
||||
CFG_ADB_DEVICE_STATUS=$(1)
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(if $(findstring android, $(target)), \
|
||||
$(if $(findstring adb,$(CFG_ADB)), \
|
||||
$(if $(findstring device,$(shell $(CFG_ADB) devices 2>/dev/null | grep -E '^[_A-Za-z0-9-]+[[:blank:]]+device')), \
|
||||
$(info install: install-runtime-target for $(target) enabled \
|
||||
$(info install: android device attached) \
|
||||
$(eval $(call DEF_ADB_DEVICE_STATUS, true))), \
|
||||
$(info install: install-runtime-target for $(target) disabled \
|
||||
$(info install: android device not attached) \
|
||||
$(eval $(call DEF_ADB_DEVICE_STATUS, false))) \
|
||||
), \
|
||||
$(info install: install-runtime-target for $(target) disabled \
|
||||
$(info install: adb not found) \
|
||||
$(eval $(call DEF_ADB_DEVICE_STATUS, false))) \
|
||||
), \
|
||||
) \
|
||||
)
|
||||
|
||||
ifeq (install-runtime-target,$(firstword $(MAKECMDGOALS)))
|
||||
$(eval $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS)):;@:)
|
||||
L_TOKEN := $(word 2,$(MAKECMDGOALS))
|
||||
ifeq ($(L_TOKEN),)
|
||||
CFG_RUNTIME_PUSH_DIR=/system/lib
|
||||
else
|
||||
CFG_RUNTIME_PUSH_DIR=$(L_TOKEN)
|
||||
endif
|
||||
|
||||
ifeq ($(CFG_ADB_DEVICE_STATUS),true)
|
||||
ifdef VERBOSE
|
||||
ADB = adb $(1)
|
||||
ADB_PUSH = adb push $(1) $(2)
|
||||
ADB_SHELL = adb shell $(1) $(2)
|
||||
else
|
||||
ADB = $(Q)$(call E, adb $(1)) && adb $(1) 1>/dev/null
|
||||
ADB_PUSH = $(Q)$(call E, adb push $(1)) && adb push $(1) $(2) 1>/dev/null
|
||||
ADB_SHELL = $(Q)$(call E, adb shell $(1) $(2)) && adb shell $(1) $(2) 1>/dev/null
|
||||
endif
|
||||
|
||||
define INSTALL_RUNTIME_TARGET_N
|
||||
install-runtime-target-$(1)-host-$(2): $$(TSREQ$$(ISTAGE)_T_$(1)_H_$(2)) $$(SREQ$$(ISTAGE)_T_$(1)_H_$(2))
|
||||
$$(Q)$$(call ADB_SHELL,mkdir,$(CFG_RUNTIME_PUSH_DIR))
|
||||
$$(Q)$$(foreach crate,$$(TARGET_CRATES_$(1)), \
|
||||
$$(call ADB_PUSH,$$(TL$(1)$(2))/$$(call CFG_LIB_GLOB_$(1),$$(crate)), \
|
||||
$$(CFG_RUNTIME_PUSH_DIR));)
|
||||
endef
|
||||
|
||||
define INSTALL_RUNTIME_TARGET_CLEANUP_N
|
||||
install-runtime-target-$(1)-cleanup:
|
||||
$$(Q)$$(call ADB,remount)
|
||||
$$(Q)$$(foreach crate,$$(TARGET_CRATES_$(1)), \
|
||||
$$(call ADB_SHELL,rm,$$(CFG_RUNTIME_PUSH_DIR)/$$(call CFG_LIB_GLOB_$(1),$$(crate)));)
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(if $(findstring $(CFG_ADB_DEVICE_STATUS),"true"), \
|
||||
$(eval $(call INSTALL_RUNTIME_TARGET_N,$(taget),$(CFG_BUILD))) \
|
||||
$(eval $(call INSTALL_RUNTIME_TARGET_CLEANUP_N,$(target))) \
|
||||
))
|
||||
|
||||
install-runtime-target: \
|
||||
install-runtime-target-arm-linux-androideabi-cleanup \
|
||||
install-runtime-target-arm-linux-androideabi-host-$(CFG_BUILD)
|
||||
else
|
||||
install-runtime-target:
|
||||
@echo "No device to install runtime library"
|
||||
@echo
|
||||
endif
|
||||
endif
|
||||
124
mk/llvm.mk
124
mk/llvm.mk
@ -1,124 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
|
||||
ifdef CFG_ENABLE_FAST_MAKE
|
||||
LLVM_DEPS := $(S)/.gitmodules
|
||||
else
|
||||
|
||||
# This is just a rough approximation of LLVM deps
|
||||
LLVM_DEPS_SRC=$(call rwildcard,$(CFG_LLVM_SRC_DIR)lib,*cpp *hpp)
|
||||
LLVM_DEPS_INC=$(call rwildcard,$(CFG_LLVM_SRC_DIR)include,*cpp *hpp)
|
||||
LLVM_DEPS=$(LLVM_DEPS_SRC) $(LLVM_DEPS_INC)
|
||||
endif
|
||||
|
||||
ifdef CFG_DISABLE_OPTIMIZE_LLVM
|
||||
LLVM_BUILD_CONFIG_MODE := Debug
|
||||
else ifdef CFG_ENABLE_LLVM_RELEASE_DEBUGINFO
|
||||
LLVM_BUILD_CONFIG_MODE := RelWithDebInfo
|
||||
else
|
||||
LLVM_BUILD_CONFIG_MODE := Release
|
||||
endif
|
||||
|
||||
define DEF_LLVM_RULES
|
||||
|
||||
ifeq ($(1),$$(CFG_BUILD))
|
||||
LLVM_DEPS_TARGET_$(1) := $$(LLVM_DEPS)
|
||||
else
|
||||
LLVM_DEPS_TARGET_$(1) := $$(LLVM_DEPS) $$(LLVM_CONFIG_$$(CFG_BUILD))
|
||||
endif
|
||||
|
||||
# If CFG_LLVM_ROOT is defined then we don't build LLVM ourselves
|
||||
ifeq ($(CFG_LLVM_ROOT),)
|
||||
|
||||
LLVM_STAMP_$(1) = $(S)src/rustllvm/llvm-auto-clean-trigger
|
||||
LLVM_DONE_$(1) = $$(CFG_LLVM_BUILD_DIR_$(1))/llvm-finished-building
|
||||
|
||||
$$(LLVM_CONFIG_$(1)): $$(LLVM_DONE_$(1))
|
||||
|
||||
ifneq ($$(CFG_NINJA),)
|
||||
BUILD_LLVM_$(1) := $$(CFG_NINJA) -C $$(CFG_LLVM_BUILD_DIR_$(1))
|
||||
else ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
BUILD_LLVM_$(1) := $$(CFG_CMAKE) --build $$(CFG_LLVM_BUILD_DIR_$(1)) \
|
||||
--config $$(LLVM_BUILD_CONFIG_MODE)
|
||||
else
|
||||
BUILD_LLVM_$(1) := $$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1))
|
||||
endif
|
||||
|
||||
$$(LLVM_DONE_$(1)): $$(LLVM_DEPS_TARGET_$(1)) $$(LLVM_STAMP_$(1))
|
||||
@$$(call E, cmake: llvm)
|
||||
$$(Q)if ! cmp $$(LLVM_STAMP_$(1)) $$(LLVM_DONE_$(1)); then \
|
||||
$$(MAKE) clean-llvm$(1); \
|
||||
$$(BUILD_LLVM_$(1)); \
|
||||
fi
|
||||
$$(Q)cp $$(LLVM_STAMP_$(1)) $$@
|
||||
|
||||
ifneq ($$(CFG_NINJA),)
|
||||
clean-llvm$(1):
|
||||
@$$(call E, clean: llvm)
|
||||
$$(Q)$$(CFG_NINJA) -C $$(CFG_LLVM_BUILD_DIR_$(1)) -t clean
|
||||
else ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
clean-llvm$(1):
|
||||
@$$(call E, clean: llvm)
|
||||
$$(Q)$$(CFG_CMAKE) --build $$(CFG_LLVM_BUILD_DIR_$(1)) \
|
||||
--config $$(LLVM_BUILD_CONFIG_MODE) \
|
||||
--target clean
|
||||
else
|
||||
clean-llvm$(1):
|
||||
@$$(call E, clean: llvm)
|
||||
$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) clean
|
||||
endif
|
||||
|
||||
else
|
||||
clean-llvm$(1):
|
||||
endif
|
||||
|
||||
$$(LLVM_AR_$(1)): $$(LLVM_CONFIG_$(1))
|
||||
|
||||
ifeq ($$(CFG_ENABLE_LLVM_STATIC_STDCPP),1)
|
||||
LLVM_STDCPP_RUSTFLAGS_$(1) = -L "$$(dir $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
|
||||
-print-file-name=lib$(CFG_STDCPP_NAME).a))"
|
||||
else
|
||||
LLVM_STDCPP_RUSTFLAGS_$(1) =
|
||||
endif
|
||||
|
||||
|
||||
# LLVM linkage:
|
||||
# Note: Filter with llvm-config so that optional targets which aren't present
|
||||
# don't cause errors (ie PNaCl's target is only present within PNaCl's LLVM
|
||||
# fork).
|
||||
LLVM_LINKAGE_PATH_$(1):=$$(abspath $$(RT_OUTPUT_DIR_$(1))/llvmdeps.rs)
|
||||
$$(LLVM_LINKAGE_PATH_$(1)): $(S)src/etc/mklldeps.py $$(LLVM_CONFIG_$(1))
|
||||
$(Q)$(CFG_PYTHON) "$$<" "$$@" "$$(filter $$(shell \
|
||||
$$(LLVM_CONFIG_$(1)) --components), \
|
||||
$(LLVM_OPTIONAL_COMPONENTS)) $(LLVM_REQUIRED_COMPONENTS)" \
|
||||
"$$(CFG_ENABLE_LLVM_STATIC_STDCPP)" $$(LLVM_CONFIG_$(1)) \
|
||||
"$(CFG_STDCPP_NAME)" "$$(CFG_USING_LIBCPP)"
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call DEF_LLVM_RULES,$(host))))
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval LLVM_CONFIGS := $(LLVM_CONFIGS) $(LLVM_CONFIG_$(host))))
|
||||
|
||||
# This can't be done in target.mk because it's included before this file.
|
||||
define LLVM_LINKAGE_DEPS
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.rustc_llvm: $$(LLVM_LINKAGE_PATH_$(2))
|
||||
RUSTFLAGS$(1)_rustc_llvm_T_$(2) += $$(shell echo $$(LLVM_ALL_COMPONENTS_$(2)) | tr '-' '_' |\
|
||||
sed -e 's/^ //;s/\([^ ]*\)/\-\-cfg "llvm_component=\\"\1\\""/g')
|
||||
endef
|
||||
|
||||
$(foreach source,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call LLVM_LINKAGE_DEPS,0,$(target),$(source))) \
|
||||
$(eval $(call LLVM_LINKAGE_DEPS,1,$(target),$(source))) \
|
||||
$(eval $(call LLVM_LINKAGE_DEPS,2,$(target),$(source))) \
|
||||
$(eval $(call LLVM_LINKAGE_DEPS,3,$(target),$(source)))))
|
||||
641
mk/main.mk
641
mk/main.mk
@ -1,641 +0,0 @@
|
||||
# Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# Version numbers and strings
|
||||
######################################################################
|
||||
|
||||
# The version number
|
||||
CFG_RELEASE_NUM=1.17.0
|
||||
|
||||
# An optional number to put after the label, e.g. '.2' -> '-beta.2'
|
||||
# NB Make sure it starts with a dot to conform to semver pre-release
|
||||
# versions (section 9)
|
||||
CFG_PRERELEASE_VERSION=.1
|
||||
|
||||
ifeq ($(CFG_RELEASE_CHANNEL),stable)
|
||||
# This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly"
|
||||
CFG_RELEASE=$(CFG_RELEASE_NUM)
|
||||
# This is the string used in dist artifact file names, e.g. "0.12.0", "nightly"
|
||||
CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
|
||||
CFG_DISABLE_UNSTABLE_FEATURES=1
|
||||
endif
|
||||
ifeq ($(CFG_RELEASE_CHANNEL),beta)
|
||||
CFG_RELEASE=$(CFG_RELEASE_NUM)-beta$(CFG_PRERELEASE_VERSION)
|
||||
# When building beta distributables just reuse the same "beta" name
|
||||
# so when we upload we'll always override the previous beta. This
|
||||
# doesn't actually impact the version reported by rustc - it's just
|
||||
# for file naming.
|
||||
CFG_PACKAGE_VERS=beta
|
||||
CFG_DISABLE_UNSTABLE_FEATURES=1
|
||||
endif
|
||||
ifeq ($(CFG_RELEASE_CHANNEL),nightly)
|
||||
CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly
|
||||
# When building nightly distributables just reuse the same "nightly" name
|
||||
# so when we upload we'll always override the previous nighly. This
|
||||
# doesn't actually impact the version reported by rustc - it's just
|
||||
# for file naming.
|
||||
CFG_PACKAGE_VERS=nightly
|
||||
endif
|
||||
ifeq ($(CFG_RELEASE_CHANNEL),dev)
|
||||
CFG_RELEASE=$(CFG_RELEASE_NUM)-dev
|
||||
CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-dev
|
||||
endif
|
||||
|
||||
# Append a version-dependent hash to each library, so we can install different
|
||||
# versions in the same place
|
||||
CFG_FILENAME_EXTRA=$(shell printf '%s' $(CFG_RELEASE)$(CFG_EXTRA_FILENAME) | $(CFG_HASH_COMMAND))
|
||||
|
||||
# If local-rust is the same major.minor as the current version, then force a local-rebuild
|
||||
ifdef CFG_ENABLE_LOCAL_RUST
|
||||
SEMVER_PREFIX=$(shell echo $(CFG_RELEASE_NUM) | grep -E -o '^[[:digit:]]+\.[[:digit:]]+')
|
||||
LOCAL_RELEASE=$(shell $(S)src/etc/local_stage0.sh --print-rustc-release $(CFG_LOCAL_RUST_ROOT))
|
||||
ifneq (,$(filter $(SEMVER_PREFIX).%,$(LOCAL_RELEASE)))
|
||||
CFG_INFO := $(info cfg: auto-detected local-rebuild using $(LOCAL_RELEASE))
|
||||
CFG_ENABLE_LOCAL_REBUILD = 1
|
||||
endif
|
||||
endif
|
||||
|
||||
# The name of the package to use for creating tarballs, installers etc.
|
||||
CFG_PACKAGE_NAME=rustc-$(CFG_PACKAGE_VERS)
|
||||
|
||||
# The version string plus commit information - this is what rustc reports
|
||||
CFG_VERSION = $(CFG_RELEASE)
|
||||
CFG_GIT_DIR := $(CFG_SRC_DIR).git
|
||||
# since $(CFG_GIT) may contain spaces (especially on Windows),
|
||||
# we need to escape them. (" " to r"\ ")
|
||||
# Note that $(subst ...) ignores space after `subst`,
|
||||
# so we use a hack: define $(SPACE) which contains space character.
|
||||
SPACE :=
|
||||
SPACE +=
|
||||
ifneq ($(CFG_GIT),)
|
||||
ifneq ($(wildcard $(subst $(SPACE),\$(SPACE),$(CFG_GIT_DIR))),)
|
||||
CFG_VER_DATE = $(shell git --git-dir='$(CFG_GIT_DIR)' log -1 --date=short --pretty=format:'%cd')
|
||||
CFG_VER_HASH = $(shell git --git-dir='$(CFG_GIT_DIR)' rev-parse HEAD)
|
||||
CFG_SHORT_VER_HASH = $(shell git --git-dir='$(CFG_GIT_DIR)' rev-parse --short=9 HEAD)
|
||||
CFG_VERSION += ($(CFG_SHORT_VER_HASH) $(CFG_VER_DATE))
|
||||
endif
|
||||
endif
|
||||
|
||||
# Windows exe's need numeric versions - don't use anything but
|
||||
# numbers and dots here
|
||||
CFG_VERSION_WIN = $(CFG_RELEASE_NUM)
|
||||
|
||||
CFG_INFO := $(info cfg: version $(CFG_VERSION))
|
||||
|
||||
######################################################################
|
||||
# More configuration
|
||||
######################################################################
|
||||
|
||||
MKFILE_DEPS := config.stamp $(call rwildcard,$(CFG_SRC_DIR)mk/,*)
|
||||
MKFILES_FOR_TARBALL:=$(MKFILE_DEPS)
|
||||
ifneq ($(NO_MKFILE_DEPS),)
|
||||
MKFILE_DEPS :=
|
||||
endif
|
||||
NON_BUILD_HOST = $(filter-out $(CFG_BUILD),$(CFG_HOST))
|
||||
NON_BUILD_TARGET = $(filter-out $(CFG_BUILD),$(CFG_TARGET))
|
||||
|
||||
ifneq ($(MAKE_RESTARTS),)
|
||||
CFG_INFO := $(info cfg: make restarts: $(MAKE_RESTARTS))
|
||||
endif
|
||||
|
||||
CFG_INFO := $(info cfg: build triple $(CFG_BUILD))
|
||||
CFG_INFO := $(info cfg: host triples $(CFG_HOST))
|
||||
CFG_INFO := $(info cfg: target triples $(CFG_TARGET))
|
||||
|
||||
ifneq ($(wildcard $(NON_BUILD_HOST)),)
|
||||
CFG_INFO := $(info cfg: non-build host triples $(NON_BUILD_HOST))
|
||||
endif
|
||||
ifneq ($(wildcard $(NON_BUILD_TARGET)),)
|
||||
CFG_INFO := $(info cfg: non-build target triples $(NON_BUILD_TARGET))
|
||||
endif
|
||||
|
||||
CFG_RUSTC_FLAGS := $(RUSTFLAGS)
|
||||
CFG_GCCISH_CFLAGS :=
|
||||
CFG_GCCISH_LINK_FLAGS :=
|
||||
|
||||
CFG_JEMALLOC_FLAGS :=
|
||||
|
||||
ifdef CFG_DISABLE_OPTIMIZE
|
||||
$(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))
|
||||
CFG_RUSTC_FLAGS +=
|
||||
CFG_JEMALLOC_FLAGS += --enable-debug
|
||||
else
|
||||
# The rtopt cfg turns off runtime sanity checks
|
||||
CFG_RUSTC_FLAGS += -O --cfg rtopt
|
||||
endif
|
||||
|
||||
CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
|
||||
|
||||
ifdef CFG_ENABLE_DEBUG_ASSERTIONS
|
||||
$(info cfg: enabling debug assertions (CFG_ENABLE_DEBUG_ASSERTIONS))
|
||||
CFG_RUSTC_FLAGS += -C debug-assertions=on
|
||||
endif
|
||||
|
||||
ifdef CFG_ENABLE_DEBUGINFO
|
||||
$(info cfg: enabling debuginfo (CFG_ENABLE_DEBUGINFO))
|
||||
CFG_RUSTC_FLAGS += -g
|
||||
else ifdef CFG_ENABLE_DEBUGINFO_LINES
|
||||
$(info cfg: enabling line number debuginfo (CFG_ENABLE_DEBUGINFO_LINES))
|
||||
CFG_RUSTC_FLAGS += -Cdebuginfo=1
|
||||
endif
|
||||
|
||||
ifdef SAVE_TEMPS
|
||||
CFG_RUSTC_FLAGS += -C save-temps
|
||||
endif
|
||||
ifdef ASM_COMMENTS
|
||||
CFG_RUSTC_FLAGS += -Z asm-comments
|
||||
endif
|
||||
ifdef TIME_PASSES
|
||||
CFG_RUSTC_FLAGS += -Z time-passes
|
||||
endif
|
||||
ifdef TIME_LLVM_PASSES
|
||||
CFG_RUSTC_FLAGS += -Z time-llvm-passes
|
||||
endif
|
||||
ifdef TRACE
|
||||
CFG_RUSTC_FLAGS += -Z trace
|
||||
endif
|
||||
ifndef CFG_DISABLE_RPATH
|
||||
CFG_RUSTC_FLAGS += -C rpath
|
||||
endif
|
||||
|
||||
# The executables crated during this compilation process have no need to include
|
||||
# static copies of libstd and libextra. We also generate dynamic versions of all
|
||||
# libraries, so in the interest of space, prefer dynamic linking throughout the
|
||||
# compilation process.
|
||||
#
|
||||
# Note though that these flags are omitted for the *bins* in stage2+. This means
|
||||
# that the snapshot will be generated with a statically linked rustc so we only
|
||||
# have to worry about the distribution of one file (with its native dynamic
|
||||
# dependencies)
|
||||
RUSTFLAGS_STAGE0 += -C prefer-dynamic
|
||||
RUSTFLAGS_STAGE1 += -C prefer-dynamic
|
||||
RUST_LIB_FLAGS_ST2 += -C prefer-dynamic
|
||||
RUST_LIB_FLAGS_ST3 += -C prefer-dynamic
|
||||
|
||||
# Landing pads require a lot of codegen. We can get through bootstrapping faster
|
||||
# by not emitting them.
|
||||
|
||||
ifdef CFG_DISABLE_STAGE0_LANDING_PADS
|
||||
RUSTFLAGS_STAGE0 += -Z no-landing-pads
|
||||
endif
|
||||
|
||||
# platform-specific auto-configuration
|
||||
include $(CFG_SRC_DIR)mk/platform.mk
|
||||
|
||||
# Run the stage1/2 compilers under valgrind
|
||||
ifdef VALGRIND_COMPILE
|
||||
CFG_VALGRIND_COMPILE := $(CFG_VALGRIND)
|
||||
else
|
||||
CFG_VALGRIND_COMPILE :=
|
||||
endif
|
||||
|
||||
|
||||
ifndef CFG_DISABLE_VALGRIND_RPASS
|
||||
$(info cfg: enabling valgrind run-pass tests (CFG_ENABLE_VALGRIND_RPASS))
|
||||
$(info cfg: valgrind-rpass command set to $(CFG_VALGRIND))
|
||||
CFG_VALGRIND_RPASS :=$(CFG_VALGRIND)
|
||||
else
|
||||
$(info cfg: disabling valgrind run-pass tests)
|
||||
CFG_VALGRIND_RPASS :=
|
||||
endif
|
||||
|
||||
|
||||
ifdef CFG_ENABLE_VALGRIND
|
||||
$(info cfg: enabling valgrind (CFG_ENABLE_VALGRIND))
|
||||
CFG_JEMALLOC_FLAGS += --enable-valgrind
|
||||
else
|
||||
CFG_VALGRIND :=
|
||||
endif
|
||||
|
||||
######################################################################
|
||||
# Target-and-rule "utility variables"
|
||||
######################################################################
|
||||
|
||||
define DEF_FOR_TARGET
|
||||
X_$(1) := $(CFG_EXE_SUFFIX_$(1))
|
||||
ifndef CFG_LLVM_TARGET_$(1)
|
||||
CFG_LLVM_TARGET_$(1) := $(1)
|
||||
endif
|
||||
endef
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call DEF_FOR_TARGET,$(target))))
|
||||
|
||||
# "Source" files we generate in builddir along the way.
|
||||
GENERATED :=
|
||||
|
||||
# Delete the built-in rules.
|
||||
.SUFFIXES:
|
||||
%:: %,v
|
||||
%:: RCS/%,v
|
||||
%:: RCS/%
|
||||
%:: s.%
|
||||
%:: SCCS/s.%
|
||||
|
||||
|
||||
######################################################################
|
||||
# Cleaning out old crates
|
||||
######################################################################
|
||||
|
||||
# $(1) is the path for directory to match against
|
||||
# $(2) is the glob to use in the match
|
||||
#
|
||||
# Note that a common bug is to accidentally construct the glob denoted
|
||||
# by $(2) with a space character prefix, which invalidates the
|
||||
# construction $(1)$(2).
|
||||
define CHECK_FOR_OLD_GLOB_MATCHES
|
||||
$(Q)MATCHES="$(wildcard $(1))"; if [ -n "$$MATCHES" ] ; then echo "warning: there are previous" \'$(notdir $(2))\' "libraries:" $$MATCHES; fi
|
||||
endef
|
||||
|
||||
# Same interface as above, but deletes rather than just listing the files.
|
||||
ifdef VERBOSE
|
||||
define REMOVE_ALL_OLD_GLOB_MATCHES
|
||||
$(Q)MATCHES="$(wildcard $(1))"; if [ -n "$$MATCHES" ] ; then echo "warning: removing previous" \'$(notdir $(1))\' "libraries:" $$MATCHES; rm $$MATCHES ; fi
|
||||
endef
|
||||
else
|
||||
define REMOVE_ALL_OLD_GLOB_MATCHES
|
||||
$(Q)MATCHES="$(wildcard $(1))"; if [ -n "$$MATCHES" ] ; then rm $$MATCHES ; fi
|
||||
endef
|
||||
endif
|
||||
|
||||
# We use a different strategy for LIST_ALL_OLD_GLOB_MATCHES_EXCEPT
|
||||
# than in the macros above because it needs the result of running the
|
||||
# `ls` command after other rules in the command list have run; the
|
||||
# macro-expander for $(wildcard ...) would deliver its results too
|
||||
# soon. (This is in contrast to the macros above, which are meant to
|
||||
# be run at the outset of a command list in a rule.)
|
||||
ifdef VERBOSE
|
||||
define LIST_ALL_OLD_GLOB_MATCHES
|
||||
@echo "info: now are following matches for" '$(notdir $(1))' "libraries:"
|
||||
@( ls $(1) 2>/dev/null || true )
|
||||
endef
|
||||
else
|
||||
define LIST_ALL_OLD_GLOB_MATCHES
|
||||
endef
|
||||
endif
|
||||
|
||||
######################################################################
|
||||
# LLVM macros
|
||||
######################################################################
|
||||
|
||||
LLVM_OPTIONAL_COMPONENTS=x86 arm aarch64 mips powerpc pnacl systemz jsbackend msp430 sparc
|
||||
LLVM_REQUIRED_COMPONENTS=ipo bitreader bitwriter linker asmparser mcjit \
|
||||
interpreter instrumentation
|
||||
|
||||
ifneq ($(CFG_LLVM_ROOT),)
|
||||
# Ensure we only try to link targets that the installed LLVM actually has:
|
||||
LLVM_COMPONENTS := $(filter $(shell $(CFG_LLVM_ROOT)/bin/llvm-config$(X_$(CFG_BUILD)) --components),\
|
||||
$(LLVM_OPTIONAL_COMPONENTS)) $(LLVM_REQUIRED_COMPONENTS)
|
||||
else
|
||||
LLVM_COMPONENTS := $(LLVM_OPTIONAL_COMPONENTS) $(LLVM_REQUIRED_COMPONENTS)
|
||||
endif
|
||||
|
||||
# Only build these LLVM tools
|
||||
LLVM_TOOLS=bugpoint llc llvm-ar llvm-as llvm-dis llvm-mc opt llvm-extract
|
||||
|
||||
define DEF_LLVM_VARS
|
||||
# The configure script defines these variables with the target triples
|
||||
# separated by Z. This defines new ones with the expected format.
|
||||
ifeq ($$(CFG_LLVM_ROOT),)
|
||||
CFG_LLVM_BUILD_DIR_$(1):=$$(CFG_LLVM_BUILD_DIR_$(subst -,_,$(1)))
|
||||
CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_INST_DIR_$(subst -,_,$(1)))
|
||||
else
|
||||
CFG_LLVM_INST_DIR_$(1):=$$(CFG_LLVM_ROOT)
|
||||
endif
|
||||
|
||||
# Any rules that depend on LLVM should depend on LLVM_CONFIG
|
||||
LLVM_CONFIG_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-config$$(X_$(1))
|
||||
LLVM_MC_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-mc$$(X_$(1))
|
||||
LLVM_AR_$(1):=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-ar$$(X_$(1))
|
||||
LLVM_VERSION_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --version)
|
||||
LLVM_BINDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --bindir)
|
||||
LLVM_INCDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --includedir)
|
||||
LLVM_LIBDIR_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --libdir)
|
||||
LLVM_LIBDIR_RUSTFLAGS_$(1)=-L native="$$(LLVM_LIBDIR_$(1))"
|
||||
LLVM_LDFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --ldflags)
|
||||
ifeq ($$(findstring freebsd,$(1)),freebsd)
|
||||
# On FreeBSD, it may search wrong headers (that are for pre-installed LLVM),
|
||||
# so we replace -I with -iquote to ensure that it searches bundled LLVM first.
|
||||
LLVM_CXXFLAGS_$(1)=$$(subst -I, -iquote , $$(shell "$$(LLVM_CONFIG_$(1))" --cxxflags))
|
||||
else
|
||||
LLVM_CXXFLAGS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --cxxflags)
|
||||
endif
|
||||
LLVM_HOST_TRIPLE_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --host-target)
|
||||
|
||||
LLVM_AS_$(1)=$$(CFG_LLVM_INST_DIR_$(1))/bin/llvm-as$$(X_$(1))
|
||||
LLC_$(1)=$$(CFG_LLVM_INST_DIR_$(1))/bin/llc$$(X_$(1))
|
||||
|
||||
LLVM_ALL_COMPONENTS_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --components)
|
||||
LLVM_VERSION_$(1)=$$(shell "$$(LLVM_CONFIG_$(1))" --version)
|
||||
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call DEF_LLVM_VARS,$(host))))
|
||||
|
||||
######################################################################
|
||||
# Exports for sub-utilities
|
||||
######################################################################
|
||||
|
||||
# Note that any variable that re-configure should pick up needs to be
|
||||
# exported
|
||||
|
||||
export CFG_SRC_DIR
|
||||
export CFG_SRC_DIR_RELATIVE
|
||||
export CFG_BUILD_DIR
|
||||
ifdef CFG_VER_DATE
|
||||
export CFG_VER_DATE
|
||||
endif
|
||||
ifdef CFG_VER_HASH
|
||||
export CFG_VER_HASH
|
||||
endif
|
||||
export CFG_VERSION
|
||||
export CFG_VERSION_WIN
|
||||
export CFG_RELEASE
|
||||
export CFG_PACKAGE_NAME
|
||||
export CFG_BUILD
|
||||
export CFG_RELEASE_CHANNEL
|
||||
export CFG_LLVM_ROOT
|
||||
export CFG_PREFIX
|
||||
export CFG_LIBDIR
|
||||
export CFG_LIBDIR_RELATIVE
|
||||
export CFG_DISABLE_INJECT_STD_VERSION
|
||||
ifdef CFG_DISABLE_UNSTABLE_FEATURES
|
||||
CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES))
|
||||
# Turn on feature-staging
|
||||
export CFG_DISABLE_UNSTABLE_FEATURES
|
||||
# Subvert unstable feature lints to do the self-build
|
||||
endif
|
||||
ifdef CFG_MUSL_ROOT
|
||||
export CFG_MUSL_ROOT
|
||||
endif
|
||||
|
||||
export RUSTC_BOOTSTRAP := 1
|
||||
|
||||
######################################################################
|
||||
# Per-stage targets and runner
|
||||
######################################################################
|
||||
|
||||
# Valid setting-strings are 'all', 'none', 'gdb', 'lldb'
|
||||
# This 'function' will determine which debugger scripts to copy based on a
|
||||
# target triple. See debuggers.mk for more information.
|
||||
TRIPLE_TO_DEBUGGER_SCRIPT_SETTING=\
|
||||
$(if $(findstring windows-msvc,$(1)),none,all)
|
||||
|
||||
STAGES = 0 1 2 3
|
||||
|
||||
define SREQ
|
||||
# $(1) is the stage number
|
||||
# $(2) is the target triple
|
||||
# $(3) is the host triple
|
||||
|
||||
# Destinations of artifacts for the host compiler
|
||||
HROOT$(1)_H_$(3) = $(3)/stage$(1)
|
||||
HBIN$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/bin
|
||||
|
||||
ifeq ($$(CFG_WINDOWSY_$(3)),1)
|
||||
# On Windows we always store host runtime libraries in the 'bin' directory because
|
||||
# there's no rpath. Target libraries go under $CFG_LIBDIR_RELATIVE (usually 'lib').
|
||||
HLIB_RELATIVE$(1)_H_$(3) = bin
|
||||
TROOT$(1)_T_$(2)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(CFG_LIBDIR_RELATIVE)/rustlib/$(2)
|
||||
# Remove the next 3 lines after a snapshot
|
||||
ifeq ($(1),0)
|
||||
RUSTFLAGS_STAGE0 += -L $$(TROOT$(1)_T_$(2)_H_$(3))/lib
|
||||
endif
|
||||
|
||||
else
|
||||
|
||||
ifeq ($(1),0)
|
||||
HLIB_RELATIVE$(1)_H_$(3) = lib
|
||||
else
|
||||
HLIB_RELATIVE$(1)_H_$(3) = $$(CFG_LIBDIR_RELATIVE)
|
||||
endif
|
||||
TROOT$(1)_T_$(2)_H_$(3) = $$(HLIB$(1)_H_$(3))/rustlib/$(2)
|
||||
|
||||
endif
|
||||
HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/$$(HLIB_RELATIVE$(1)_H_$(3))
|
||||
|
||||
# Destinations of artifacts for target architectures
|
||||
TBIN$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/bin
|
||||
TLIB$(1)_T_$(2)_H_$(3) = $$(TROOT$(1)_T_$(2)_H_$(3))/lib
|
||||
|
||||
# Preqrequisites for using the stageN compiler
|
||||
ifeq ($(1),0)
|
||||
HSREQ$(1)_H_$(3) = $$(HBIN$(1)_H_$(3))/rustc$$(X_$(3))
|
||||
else
|
||||
HSREQ$(1)_H_$(3) = \
|
||||
$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
|
||||
$$(MKFILE_DEPS) \
|
||||
tmp/install-debugger-scripts$(1)_H_$(3)-$$(call TRIPLE_TO_DEBUGGER_SCRIPT_SETTING,$(3)).done
|
||||
endif
|
||||
|
||||
# Prerequisites for using the stageN compiler to build target artifacts
|
||||
TSREQ$(1)_T_$(2)_H_$(3) = \
|
||||
$$(HSREQ$(1)_H_$(3)) \
|
||||
$$(foreach obj,$$(REQUIRED_OBJECTS_$(2)),\
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/$$(obj))
|
||||
|
||||
# Prerequisites for a working stageN compiler and libraries, for a specific
|
||||
# target
|
||||
SREQ$(1)_T_$(2)_H_$(3) = \
|
||||
$$(TSREQ$(1)_T_$(2)_H_$(3)) \
|
||||
$$(foreach dep,$$(TARGET_CRATES_$(2)), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep)) \
|
||||
tmp/install-debugger-scripts$(1)_T_$(2)_H_$(3)-$$(call TRIPLE_TO_DEBUGGER_SCRIPT_SETTING,$(2)).done
|
||||
|
||||
# Prerequisites for a working stageN compiler and complete set of target
|
||||
# libraries
|
||||
CSREQ$(1)_T_$(2)_H_$(3) = \
|
||||
$$(TSREQ$(1)_T_$(2)_H_$(3)) \
|
||||
$$(HBIN$(1)_H_$(3))/rustdoc$$(X_$(3)) \
|
||||
$$(foreach dep,$$(HOST_CRATES),$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep))
|
||||
|
||||
ifeq ($(1),0)
|
||||
# Don't run the stage0 compiler under valgrind - that ship has sailed
|
||||
CFG_VALGRIND_COMPILE$(1) =
|
||||
else
|
||||
CFG_VALGRIND_COMPILE$(1) = $$(CFG_VALGRIND_COMPILE)
|
||||
endif
|
||||
|
||||
# Add RUSTFLAGS_STAGEN values to the build command
|
||||
EXTRAFLAGS_STAGE$(1) = $$(RUSTFLAGS_STAGE$(1))
|
||||
|
||||
CFGFLAG$(1)_T_$(2)_H_$(3) = stage$(1)
|
||||
|
||||
endef
|
||||
|
||||
# Same macro/variables as above, but defined in a separate loop so it can use
|
||||
# all the variables above for all archs. The RPATH_VAR setup sometimes needs to
|
||||
# reach across triples to get things in order.
|
||||
#
|
||||
# Defines (with the standard $(1)_T_$(2)_H_$(3) suffix):
|
||||
# * `LD_LIBRARY_PATH_ENV_NAME`: the name for the key to use in the OS
|
||||
# environment to access or extend the lookup path for dynamic
|
||||
# libraries. Note on Windows, that key is `$PATH`, and thus not
|
||||
# only conflates programs with dynamic libraries, but also often
|
||||
# contains spaces which confuse make.
|
||||
# * `LD_LIBRARY_PATH_ENV_HOSTDIR`: the entry to add to lookup path for the host
|
||||
# * `LD_LIBRARY_PATH_ENV_TARGETDIR`: the entry to add to lookup path for target
|
||||
#
|
||||
# Below that, HOST_RPATH_VAR and TARGET_RPATH_VAR are defined in terms of the
|
||||
# above settings.
|
||||
#
|
||||
define SREQ_CMDS
|
||||
|
||||
ifeq ($$(OSTYPE_$(3)),apple-darwin)
|
||||
LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := DYLD_LIBRARY_PATH
|
||||
else
|
||||
ifeq ($$(CFG_WINDOWSY_$(3)),1)
|
||||
LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := PATH
|
||||
else
|
||||
ifeq ($$(OSTYPE_$(3)),unknown-haiku)
|
||||
LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := LIBRARY_PATH
|
||||
else
|
||||
LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3) := LD_LIBRARY_PATH
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3) := \
|
||||
$$(CURDIR)/$$(HLIB$(1)_H_$(3)):$$(CFG_LLVM_INST_DIR_$(3))/lib
|
||||
LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3) := \
|
||||
$$(CURDIR)/$$(TLIB$(1)_T_$(2)_H_$(3))
|
||||
|
||||
HOST_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
|
||||
$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$(LD_LIBRARY_PATH_ENV_HOSTDIR$(1)_T_$(2)_H_$(3)):$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))
|
||||
TARGET_RPATH_VAR$(1)_T_$(2)_H_$(3) := \
|
||||
$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))=$$(LD_LIBRARY_PATH_ENV_TARGETDIR$(1)_T_$(2)_H_$(3)):$$$$$$(LD_LIBRARY_PATH_ENV_NAME$(1)_T_$(2)_H_$(3))
|
||||
|
||||
RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(HOST_RPATH_VAR$(1)_T_$(2)_H_$(3))
|
||||
|
||||
# Pass --cfg stage0 only for the build->host part of stage0;
|
||||
# if you're building a cross config, the host->* parts are
|
||||
# effectively stage1, since it uses the just-built stage0.
|
||||
#
|
||||
# Also be sure to use the right rpath because we're loading libraries from the
|
||||
# CFG_BUILD's stage1 directory for our target, so switch this one instance of
|
||||
# `RPATH_VAR` to get the bootstrap working.
|
||||
ifeq ($(1),0)
|
||||
ifneq ($(strip $(CFG_BUILD)),$(strip $(3)))
|
||||
CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
|
||||
|
||||
RPATH_VAR$(1)_T_$(2)_H_$(3) := $$(TARGET_RPATH_VAR1_T_$(2)_H_$$(CFG_BUILD))
|
||||
else
|
||||
ifdef CFG_ENABLE_LOCAL_REBUILD
|
||||
# Assume the local-rebuild rustc already has stage1 features too.
|
||||
CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
STAGE$(1)_T_$(2)_H_$(3) := \
|
||||
$$(Q)$$(RPATH_VAR$(1)_T_$(2)_H_$(3)) \
|
||||
$$(call CFG_RUN_TARG_$(3),$(1), \
|
||||
$$(CFG_VALGRIND_COMPILE$(1)) \
|
||||
$$(HBIN$(1)_H_$(3))/rustc$$(X_$(3)) \
|
||||
--cfg $$(CFGFLAG$(1)_T_$(2)_H_$(3)) \
|
||||
$$(CFG_RUSTC_FLAGS) $$(EXTRAFLAGS_STAGE$(1)) --target=$(2)) \
|
||||
$$(RUSTC_FLAGS_$(2))
|
||||
|
||||
endef
|
||||
|
||||
$(foreach build,$(CFG_HOST), \
|
||||
$(eval $(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(foreach stage,$(STAGES), \
|
||||
$(eval $(call SREQ,$(stage),$(target),$(build))))))))
|
||||
|
||||
$(foreach build,$(CFG_HOST), \
|
||||
$(eval $(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(foreach stage,$(STAGES), \
|
||||
$(eval $(call SREQ_CMDS,$(stage),$(target),$(build))))))))
|
||||
|
||||
######################################################################
|
||||
# rustc-H-targets
|
||||
#
|
||||
# Builds a functional Rustc for the given host.
|
||||
######################################################################
|
||||
|
||||
define DEF_RUSTC_STAGE_TARGET
|
||||
# $(1) == architecture
|
||||
# $(2) == stage
|
||||
|
||||
rustc-stage$(2)-H-$(1): \
|
||||
$$(foreach target,$$(CFG_TARGET),$$(SREQ$(2)_T_$$(target)_H_$(1)))
|
||||
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(foreach stage,1 2 3, \
|
||||
$(eval $(call DEF_RUSTC_STAGE_TARGET,$(host),$(stage))))))
|
||||
|
||||
rustc-stage1: rustc-stage1-H-$(CFG_BUILD)
|
||||
rustc-stage2: rustc-stage2-H-$(CFG_BUILD)
|
||||
rustc-stage3: rustc-stage3-H-$(CFG_BUILD)
|
||||
|
||||
define DEF_RUSTC_TARGET
|
||||
# $(1) == architecture
|
||||
|
||||
rustc-H-$(1): rustc-stage2-H-$(1)
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_TARGET), \
|
||||
$(eval $(call DEF_RUSTC_TARGET,$(host))))
|
||||
|
||||
rustc-stage1: rustc-stage1-H-$(CFG_BUILD)
|
||||
rustc-stage2: rustc-stage2-H-$(CFG_BUILD)
|
||||
rustc-stage3: rustc-stage3-H-$(CFG_BUILD)
|
||||
rustc: rustc-H-$(CFG_BUILD)
|
||||
|
||||
rustc-H-all: $(foreach host,$(CFG_HOST),rustc-H-$(host))
|
||||
|
||||
######################################################################
|
||||
# Entrypoint rule
|
||||
######################################################################
|
||||
|
||||
.DEFAULT_GOAL := all
|
||||
|
||||
define ALL_TARGET_N
|
||||
ifneq ($$(findstring $(1),$$(CFG_HOST)),)
|
||||
# This is a host
|
||||
all-target-$(1)-host-$(2): $$(CSREQ2_T_$(1)_H_$(2))
|
||||
else
|
||||
# This is a target only
|
||||
all-target-$(1)-host-$(2): $$(SREQ2_T_$(1)_H_$(2))
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call ALL_TARGET_N,$(target),$(host)))))
|
||||
|
||||
ALL_TARGET_RULES = $(foreach target,$(CFG_TARGET), \
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
all-target-$(target)-host-$(host)))
|
||||
|
||||
all-no-docs: $(ALL_TARGET_RULES) $(GENERATED)
|
||||
all: all-no-docs docs
|
||||
|
||||
######################################################################
|
||||
# Build system documentation
|
||||
######################################################################
|
||||
|
||||
# $(1) is the name of the doc <section> in Makefile.in
|
||||
# pick everything between tags | remove first line | remove last line
|
||||
# | remove extra (?) line | strip leading `#` from lines
|
||||
SHOW_DOCS = $(Q)awk '/<$(1)>/,/<\/$(1)>/' $(S)/Makefile.in | sed '1d' | sed '$$d' | sed 's/^\# \?//'
|
||||
|
||||
help:
|
||||
$(call SHOW_DOCS,help)
|
||||
|
||||
tips:
|
||||
$(call SHOW_DOCS,tips)
|
||||
|
||||
nitty-gritty:
|
||||
$(call SHOW_DOCS,nitty-gritty)
|
||||
250
mk/platform.mk
250
mk/platform.mk
@ -1,250 +0,0 @@
|
||||
# Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
|
||||
# Create variables HOST_<triple> containing the host part
|
||||
# of each target triple. For example, the triple i686-darwin-macos
|
||||
# would create a variable HOST_i686-darwin-macos with the value
|
||||
# i386.
|
||||
define DEF_HOST_VAR
|
||||
HOST_$(1) = $(patsubst i%86,i386,$(word 1,$(subst -, ,$(1))))
|
||||
endef
|
||||
$(foreach t,$(CFG_TARGET),$(eval $(call DEF_HOST_VAR,$(t))))
|
||||
$(foreach t,$(CFG_TARGET),$(info cfg: host for $(t) is $(HOST_$(t))))
|
||||
|
||||
# Ditto for OSTYPE
|
||||
define DEF_OSTYPE_VAR
|
||||
OSTYPE_$(1) = $(subst $(firstword $(subst -, ,$(1)))-,,$(1))
|
||||
endef
|
||||
$(foreach t,$(CFG_TARGET),$(eval $(call DEF_OSTYPE_VAR,$(t))))
|
||||
$(foreach t,$(CFG_TARGET),$(info cfg: os for $(t) is $(OSTYPE_$(t))))
|
||||
|
||||
# On Darwin, we need to run dsymutil so the debugging information ends
|
||||
# up in the right place. On other platforms, it automatically gets
|
||||
# embedded into the executable, so use a no-op command.
|
||||
CFG_DSYMUTIL := true
|
||||
|
||||
# Hack: not sure how to test if a file exists in make other than this
|
||||
OS_SUPP = $(patsubst %,--suppressions=%, \
|
||||
$(wildcard $(CFG_SRC_DIR)src/etc/$(CFG_OSTYPE).supp*))
|
||||
|
||||
ifdef CFG_DISABLE_OPTIMIZE_CXX
|
||||
$(info cfg: disabling C++ optimization (CFG_DISABLE_OPTIMIZE_CXX))
|
||||
CFG_GCCISH_CFLAGS += -O0
|
||||
else
|
||||
CFG_GCCISH_CFLAGS += -O2
|
||||
endif
|
||||
|
||||
# The soname thing is for supporting a statically linked jemalloc.
|
||||
# see https://blog.mozilla.org/jseward/2012/06/05/valgrind-now-supports-jemalloc-builds-directly/
|
||||
ifdef CFG_VALGRIND
|
||||
CFG_VALGRIND += --error-exitcode=100 \
|
||||
--fair-sched=try \
|
||||
--quiet \
|
||||
--soname-synonyms=somalloc=NONE \
|
||||
--suppressions=$(CFG_SRC_DIR)src/etc/x86.supp \
|
||||
$(OS_SUPP)
|
||||
ifdef CFG_ENABLE_HELGRIND
|
||||
CFG_VALGRIND += --tool=helgrind
|
||||
else
|
||||
CFG_VALGRIND += --tool=memcheck \
|
||||
--leak-check=full
|
||||
endif
|
||||
endif
|
||||
|
||||
# If we actually want to run Valgrind on a given platform, set this variable
|
||||
define DEF_GOOD_VALGRIND
|
||||
ifeq ($(OSTYPE_$(1)),unknown-linux-gnu)
|
||||
GOOD_VALGRIND_$(1) = 1
|
||||
endif
|
||||
ifneq (,$(filter $(OSTYPE_$(1)),apple-darwin freebsd))
|
||||
ifeq ($(HOST_$(1)),x86_64)
|
||||
GOOD_VALGRIND_$(1) = 1
|
||||
endif
|
||||
endif
|
||||
ifdef GOOD_VALGRIND_$(t)
|
||||
$$(info cfg: have good valgrind for $(t))
|
||||
else
|
||||
$$(info cfg: no good valgrind for $(t))
|
||||
endif
|
||||
endef
|
||||
$(foreach t,$(CFG_TARGET),$(eval $(call DEF_GOOD_VALGRIND,$(t))))
|
||||
|
||||
AR := ar
|
||||
|
||||
define SET_FROM_CFG
|
||||
ifdef CFG_$(1)
|
||||
ifeq ($(origin $(1)),undefined)
|
||||
$$(info cfg: using $(1)=$(CFG_$(1)) (CFG_$(1)))
|
||||
$(1)=$(CFG_$(1))
|
||||
endif
|
||||
ifeq ($(origin $(1)),default)
|
||||
$$(info cfg: using $(1)=$(CFG_$(1)) (CFG_$(1)))
|
||||
$(1)=$(CFG_$(1))
|
||||
endif
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach cvar,CC CXX CPP CFLAGS CXXFLAGS CPPFLAGS, \
|
||||
$(eval $(call SET_FROM_CFG,$(cvar))))
|
||||
|
||||
CFG_RLIB_GLOB=lib$(1)-*.rlib
|
||||
|
||||
include $(wildcard $(CFG_SRC_DIR)mk/cfg/*.mk)
|
||||
|
||||
define ADD_INSTALLED_OBJECTS
|
||||
INSTALLED_OBJECTS_$(1) += $$(CFG_INSTALLED_OBJECTS_$(1))
|
||||
REQUIRED_OBJECTS_$(1) += $$(CFG_THIRD_PARTY_OBJECTS_$(1))
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call ADD_INSTALLED_OBJECTS,$(target))))
|
||||
|
||||
define DEFINE_LINKER
|
||||
ifndef LINK_$(1)
|
||||
LINK_$(1) := $$(CC_$(1))
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call DEFINE_LINKER,$(target))))
|
||||
|
||||
define ADD_JEMALLOC_DEP
|
||||
ifndef CFG_DISABLE_JEMALLOC_$(1)
|
||||
ifndef CFG_DISABLE_JEMALLOC
|
||||
RUST_DEPS_std_T_$(1) += alloc_jemalloc
|
||||
TARGET_CRATES_$(1) += alloc_jemalloc
|
||||
endif
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call ADD_JEMALLOC_DEP,$(target))))
|
||||
|
||||
# The -Qunused-arguments sidesteps spurious warnings from clang
|
||||
define FILTER_FLAGS
|
||||
ifeq ($$(CFG_USING_CLANG),1)
|
||||
ifneq ($(findstring clang,$$(shell $(CC_$(1)) -v)),)
|
||||
CFG_GCCISH_CFLAGS_$(1) += -Qunused-arguments
|
||||
CFG_GCCISH_CXXFLAGS_$(1) += -Qunused-arguments
|
||||
endif
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call FILTER_FLAGS,$(target))))
|
||||
|
||||
# Configure various macros to pass gcc or cl.exe style arguments
|
||||
define CC_MACROS
|
||||
CFG_CC_INCLUDE_$(1)=-I $$(1)
|
||||
ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
CFG_CC_OUTPUT_$(1)=-Fo:$$(1)
|
||||
CFG_CREATE_ARCHIVE_$(1)='$$(AR_$(1))' -OUT:$$(1)
|
||||
else
|
||||
CFG_CC_OUTPUT_$(1)=-o $$(1)
|
||||
CFG_CREATE_ARCHIVE_$(1)=$$(AR_$(1)) crus $$(1)
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call CC_MACROS,$(target))))
|
||||
|
||||
|
||||
ifeq ($(CFG_CCACHE_CPP2),1)
|
||||
CCACHE_CPP2=1
|
||||
export CCACHE_CPP
|
||||
endif
|
||||
|
||||
ifdef CFG_CCACHE_BASEDIR
|
||||
CCACHE_BASEDIR=$(CFG_CCACHE_BASEDIR)
|
||||
export CCACHE_BASEDIR
|
||||
endif
|
||||
|
||||
FIND_COMPILER = $(strip $(1:ccache=))
|
||||
|
||||
define CFG_MAKE_TOOLCHAIN
|
||||
# Prepend the tools with their prefix if cross compiling
|
||||
ifneq ($(CFG_BUILD),$(1))
|
||||
ifneq ($$(findstring msvc,$(1)),msvc)
|
||||
CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
|
||||
CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
|
||||
CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
|
||||
AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
|
||||
LINK_$(1)=$(CROSS_PREFIX_$(1))$(LINK_$(1))
|
||||
RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(LINK_$(1))) \
|
||||
-C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
|
||||
|
||||
RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
|
||||
endif
|
||||
endif
|
||||
|
||||
CFG_COMPILE_C_$(1) = '$$(call FIND_COMPILER,$$(CC_$(1)))' \
|
||||
$$(CFLAGS) \
|
||||
$$(CFG_GCCISH_CFLAGS) \
|
||||
$$(CFG_GCCISH_CFLAGS_$(1)) \
|
||||
-c $$(call CFG_CC_OUTPUT_$(1),$$(1)) $$(2)
|
||||
CFG_LINK_C_$(1) = $$(CC_$(1)) \
|
||||
$$(LDFLAGS) \
|
||||
$$(CFG_GCCISH_LINK_FLAGS) -o $$(1) \
|
||||
$$(CFG_GCCISH_LINK_FLAGS_$(1)) \
|
||||
$$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
|
||||
$$(call CFG_INSTALL_NAME_$(1),$$(4))
|
||||
CFG_COMPILE_CXX_$(1) = '$$(call FIND_COMPILER,$$(CXX_$(1)))' \
|
||||
$$(CXXFLAGS) \
|
||||
$$(CFG_GCCISH_CFLAGS) \
|
||||
$$(CFG_GCCISH_CXXFLAGS) \
|
||||
$$(CFG_GCCISH_CFLAGS_$(1)) \
|
||||
$$(CFG_GCCISH_CXXFLAGS_$(1)) \
|
||||
-c $$(call CFG_CC_OUTPUT_$(1),$$(1)) $$(2)
|
||||
CFG_LINK_CXX_$(1) = $$(CXX_$(1)) \
|
||||
$$(LDFLAGS) \
|
||||
$$(CFG_GCCISH_LINK_FLAGS) -o $$(1) \
|
||||
$$(CFG_GCCISH_LINK_FLAGS_$(1)) \
|
||||
$$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
|
||||
$$(call CFG_INSTALL_NAME_$(1),$$(4))
|
||||
|
||||
ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
|
||||
|
||||
# On Bitrig, we need the relocation model to be PIC for everything
|
||||
ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
|
||||
LLVM_MC_RELOCATION_MODEL="pic"
|
||||
else
|
||||
LLVM_MC_RELOCATION_MODEL="default"
|
||||
endif
|
||||
|
||||
# LLVM changed this flag in 3.9
|
||||
ifdef CFG_LLVM_MC_HAS_RELOCATION_MODEL
|
||||
LLVM_MC_RELOC_FLAG := -relocation-model=$$(LLVM_MC_RELOCATION_MODEL)
|
||||
else
|
||||
LLVM_MC_RELOC_FLAG := -position-independent
|
||||
endif
|
||||
|
||||
# We're using llvm-mc as our assembler because it supports
|
||||
# .cfi pseudo-ops on mac
|
||||
CFG_ASSEMBLE_$(1)=$$(CPP_$(1)) -E $$(2) | \
|
||||
$$(LLVM_MC_$$(CFG_BUILD)) \
|
||||
-assemble \
|
||||
$$(LLVM_MC_RELOC_FLAG) \
|
||||
-filetype=obj \
|
||||
-triple=$(1) \
|
||||
-o=$$(1)
|
||||
else
|
||||
|
||||
# For the ARM, AARCH64, MIPS and POWER crosses, use the toolchain assembler
|
||||
# FIXME: We should be able to use the LLVM assembler
|
||||
CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
|
||||
$$(2) -c -o $$(1)
|
||||
|
||||
endif
|
||||
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call CFG_MAKE_TOOLCHAIN,$(target))))
|
||||
251
mk/prepare.mk
251
mk/prepare.mk
@ -1,251 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# Basic support for producing installation images.
|
||||
#
|
||||
# The 'prepare' build target copies all release artifacts from the build
|
||||
# directory to some other location, placing all binaries, libraries, and
|
||||
# docs in their final locations relative to each other.
|
||||
#
|
||||
# It requires the following variables to be set:
|
||||
#
|
||||
# PREPARE_HOST - the host triple
|
||||
# PREPARE_TARGETS - the target triples, space separated
|
||||
# PREPARE_DEST_DIR - the directory to put the image
|
||||
|
||||
PREPARE_STAGE=2
|
||||
|
||||
DEFAULT_PREPARE_DIR_CMD = umask 022 && mkdir -p
|
||||
DEFAULT_PREPARE_BIN_CMD = install -m755
|
||||
DEFAULT_PREPARE_LIB_CMD = install -m644
|
||||
DEFAULT_PREPARE_MAN_CMD = install -m644
|
||||
|
||||
# Create a directory
|
||||
# $(1) is the directory
|
||||
#
|
||||
# XXX: These defines are called to generate make steps.
|
||||
# Adding blank lines means two steps from different defines will not end up on
|
||||
# the same line.
|
||||
define PREPARE_DIR
|
||||
|
||||
@$(call E, prepare: $(1))
|
||||
$(Q)$(PREPARE_DIR_CMD) $(1)
|
||||
|
||||
endef
|
||||
|
||||
# Copy an executable
|
||||
# $(1) is the filename/libname-glob
|
||||
#
|
||||
# See above for an explanation on the surrounding blank lines
|
||||
define PREPARE_BIN
|
||||
|
||||
@$(call E, prepare: $(PREPARE_DEST_BIN_DIR)/$(1))
|
||||
$(Q)$(PREPARE_BIN_CMD) $(PREPARE_SOURCE_BIN_DIR)/$(1) $(PREPARE_DEST_BIN_DIR)/$(1)
|
||||
|
||||
endef
|
||||
|
||||
# Copy a dylib or rlib
|
||||
# $(1) is the filename/libname-glob
|
||||
#
|
||||
# See above for an explanation on the surrounding blank lines
|
||||
define PREPARE_LIB
|
||||
|
||||
@$(call E, prepare: $(PREPARE_WORKING_DEST_LIB_DIR)/$(1))
|
||||
$(Q)LIB_NAME="$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1))))"; \
|
||||
MATCHES="$(filter-out %$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)))), \
|
||||
$(wildcard $(PREPARE_WORKING_DEST_LIB_DIR)/$(1)))"; \
|
||||
if [ -n "$$MATCHES" ]; then \
|
||||
echo "warning: one or libraries matching Rust library '$(1)'" && \
|
||||
echo " (other than '$$LIB_NAME' itself) already present" && \
|
||||
echo " at destination $(PREPARE_WORKING_DEST_LIB_DIR):" && \
|
||||
echo $$MATCHES ; \
|
||||
fi
|
||||
$(Q)$(PREPARE_LIB_CMD) `ls -drt1 $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)` $(PREPARE_WORKING_DEST_LIB_DIR)/
|
||||
|
||||
endef
|
||||
|
||||
# Copy a man page
|
||||
# $(1) - source dir
|
||||
#
|
||||
# See above for an explanation on the surrounding blank lines
|
||||
define PREPARE_MAN
|
||||
|
||||
@$(call E, prepare: $(PREPARE_DEST_MAN_DIR)/$(1))
|
||||
$(Q)$(PREPARE_MAN_CMD) $(PREPARE_SOURCE_MAN_DIR)/$(1) $(PREPARE_DEST_MAN_DIR)/$(1)
|
||||
|
||||
endef
|
||||
|
||||
PREPARE_TOOLS = $(filter-out compiletest rustbook error_index_generator, $(TOOLS))
|
||||
|
||||
|
||||
# $(1) is tool
|
||||
# $(2) is stage
|
||||
# $(3) is host
|
||||
# $(4) tag
|
||||
define DEF_PREPARE_HOST_TOOL
|
||||
prepare-host-tool-$(1)-$(2)-$(3)-$(4): \
|
||||
PREPARE_SOURCE_BIN_DIR=$$(HBIN$(2)_H_$(3))
|
||||
prepare-host-tool-$(1)-$(2)-$(3)-$(4): prepare-maybe-clean-$(4) \
|
||||
$$(foreach dep,$$(TOOL_DEPS_$(1)),prepare-host-lib-$$(dep)-$(2)-$(3)-$(4)) \
|
||||
$$(HBIN$(2)_H_$(3))/$(1)$$(X_$(3)) \
|
||||
prepare-host-dirs-$(4)
|
||||
$$(if $$(findstring $(2), $$(PREPARE_STAGE)), \
|
||||
$$(if $$(findstring $(3), $$(PREPARE_HOST)), \
|
||||
$$(call PREPARE_BIN,$(1)$$(X_$$(PREPARE_HOST))),),)
|
||||
$$(if $$(findstring $(2), $$(PREPARE_STAGE)), \
|
||||
$$(if $$(findstring $(3), $$(PREPARE_HOST)), \
|
||||
$$(call PREPARE_MAN,$(1).1),),)
|
||||
endef
|
||||
|
||||
# Libraries are compiled using the --libdir provided to configure, but
|
||||
# we store them in the tarball using just "lib" so that the install
|
||||
# script can then rewrite them back to the correct path.
|
||||
PREPARE_TAR_LIB_DIR = $(patsubst $(CFG_LIBDIR_RELATIVE)%,lib%,$(1))
|
||||
|
||||
# For host libraries only install dylibs, not rlibs since the host libs are only
|
||||
# used to support rustc and rustc uses dynamic linking
|
||||
#
|
||||
# $(1) is tool
|
||||
# $(2) is stage
|
||||
# $(3) is host
|
||||
# $(4) tag
|
||||
define DEF_PREPARE_HOST_LIB
|
||||
prepare-host-lib-$(1)-$(2)-$(3)-$(4): \
|
||||
PREPARE_WORKING_SOURCE_LIB_DIR=$$(HLIB$(2)_H_$(3))
|
||||
prepare-host-lib-$(1)-$(2)-$(3)-$(4): \
|
||||
PREPARE_WORKING_DEST_LIB_DIR=$$(PREPARE_DEST_DIR)/$$(call PREPARE_TAR_LIB_DIR,$$(HLIB_RELATIVE$(2)_H_$(3)))
|
||||
prepare-host-lib-$(1)-$(2)-$(3)-$(4): prepare-maybe-clean-$(4) \
|
||||
$$(foreach dep,$$(RUST_DEPS_$(1)_T_$(3)),prepare-host-lib-$$(dep)-$(2)-$(3)-$(4)) \
|
||||
$$(HLIB$(2)_H_$(3))/stamp.$(1) \
|
||||
prepare-host-dirs-$(4)
|
||||
$$(if $$(findstring $(2), $$(PREPARE_STAGE)), \
|
||||
$$(if $$(findstring $(3), $$(PREPARE_HOST)), \
|
||||
$$(if $$(findstring 1,$$(ONLY_RLIB_$(1))),, \
|
||||
$$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$$(PREPARE_HOST),$(1)))),),)
|
||||
endef
|
||||
|
||||
|
||||
# $(1) is stage
|
||||
# $(2) is target
|
||||
# $(3) is host
|
||||
# $(4) tag
|
||||
define DEF_PREPARE_TARGET_N
|
||||
# Rebind PREPARE_*_LIB_DIR to point to rustlib, then install the libs for the targets
|
||||
prepare-target-$(2)-host-$(3)-$(1)-$(4): \
|
||||
PREPARE_WORKING_SOURCE_LIB_DIR=$$(TLIB$(1)_T_$(2)_H_$(3))
|
||||
prepare-target-$(2)-host-$(3)-$(1)-$(4): \
|
||||
PREPARE_WORKING_DEST_LIB_DIR=$$(PREPARE_DEST_LIB_DIR)/rustlib/$(2)/lib
|
||||
prepare-target-$(2)-host-$(3)-$(1)-$(4): \
|
||||
PREPARE_SOURCE_BIN_DIR=$$(TBIN$(1)_T_$(2)_H_$(3))
|
||||
prepare-target-$(2)-host-$(3)-$(1)-$(4): \
|
||||
PREPARE_DEST_BIN_DIR=$$(PREPARE_DEST_LIB_DIR)/rustlib/$(3)/bin
|
||||
prepare-target-$(2)-host-$(3)-$(1)-$(4): prepare-maybe-clean-$(4) \
|
||||
$$(foreach crate,$$(TARGET_CRATES_$(2)), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)) \
|
||||
$$(if $$(findstring $(2),$$(CFG_HOST)), \
|
||||
$$(foreach crate,$$(HOST_CRATES), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate)),)
|
||||
# Only install if this host and target combo is being prepared. Also be sure to
|
||||
# *not* install the rlibs for host crates because there's no need to statically
|
||||
# link against most of them. They just produce a large amount of extra size
|
||||
# bloat.
|
||||
$$(if $$(findstring $(1), $$(PREPARE_STAGE)), \
|
||||
$$(if $$(findstring $(2), $$(PREPARE_TARGETS)), \
|
||||
$$(if $$(findstring $(3), $$(PREPARE_HOST)), \
|
||||
$$(call PREPARE_DIR,$$(PREPARE_WORKING_DEST_LIB_DIR)) \
|
||||
$$(call PREPARE_DIR,$$(PREPARE_DEST_BIN_DIR)) \
|
||||
$$(foreach crate,$$(TARGET_CRATES_$(2)), \
|
||||
$$(if $$(or $$(findstring 1, $$(ONLY_RLIB_$$(crate))),$$(findstring 1,$$(CFG_INSTALL_ONLY_RLIB_$(2)))),, \
|
||||
$$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))) \
|
||||
$$(call PREPARE_LIB,$$(call CFG_RLIB_GLOB,$$(crate)))) \
|
||||
$$(if $$(findstring $(2),$$(CFG_HOST)), \
|
||||
$$(foreach crate,$$(HOST_CRATES), \
|
||||
$$(call PREPARE_LIB,$$(call CFG_LIB_GLOB_$(2),$$(crate)))),) \
|
||||
$$(foreach object,$$(INSTALLED_OBJECTS_$(2)),\
|
||||
$$(call PREPARE_LIB,$$(object))) \
|
||||
$$(foreach bin,$$(INSTALLED_BINS_$(3)),\
|
||||
$$(call PREPARE_BIN,$$(bin))) \
|
||||
,),),)
|
||||
endef
|
||||
|
||||
define INSTALL_GDB_DEBUGGER_SCRIPTS_COMMANDS
|
||||
$(Q)$(PREPARE_BIN_CMD) $(DEBUGGER_BIN_SCRIPTS_GDB_ABS) $(PREPARE_DEST_BIN_DIR)
|
||||
$(Q)$(PREPARE_LIB_CMD) $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_GDB_ABS) $(PREPARE_DEST_LIB_DIR)/rustlib/etc
|
||||
endef
|
||||
|
||||
define INSTALL_LLDB_DEBUGGER_SCRIPTS_COMMANDS
|
||||
$(Q)$(PREPARE_BIN_CMD) $(DEBUGGER_BIN_SCRIPTS_LLDB_ABS) $(PREPARE_DEST_BIN_DIR)
|
||||
$(Q)$(PREPARE_LIB_CMD) $(DEBUGGER_RUSTLIB_ETC_SCRIPTS_LLDB_ABS) $(PREPARE_DEST_LIB_DIR)/rustlib/etc
|
||||
endef
|
||||
|
||||
define INSTALL_NO_DEBUGGER_SCRIPTS_COMMANDS
|
||||
$(Q)echo "No debugger scripts will be installed for host $(PREPARE_HOST)"
|
||||
endef
|
||||
|
||||
# $(1) is PREPARE_HOST
|
||||
INSTALL_DEBUGGER_SCRIPT_COMMANDS=$(if $(findstring windows,$(1)),\
|
||||
$(INSTALL_NO_DEBUGGER_SCRIPTS_COMMANDS),\
|
||||
$(if $(findstring darwin,$(1)),\
|
||||
$(INSTALL_LLDB_DEBUGGER_SCRIPTS_COMMANDS),\
|
||||
$(INSTALL_GDB_DEBUGGER_SCRIPTS_COMMANDS)))
|
||||
|
||||
define DEF_PREPARE
|
||||
|
||||
prepare-base-$(1)-%: PREPARE_SOURCE_MAN_DIR=$$(S)/man
|
||||
prepare-base-$(1)-%: PREPARE_DEST_BIN_DIR=$$(PREPARE_DEST_DIR)/bin
|
||||
prepare-base-$(1)-%: PREPARE_DEST_LIB_DIR=$$(PREPARE_DEST_DIR)/$$(call PREPARE_TAR_LIB_DIR,$$(CFG_LIBDIR_RELATIVE))
|
||||
prepare-base-$(1)-%: PREPARE_DEST_MAN_DIR=$$(PREPARE_DEST_DIR)/share/man/man1
|
||||
|
||||
prepare-base-$(1)-target: prepare-target-$(1)
|
||||
prepare-base-$(1)-host: prepare-host-$(1) prepare-debugger-scripts-$(1)
|
||||
|
||||
prepare-host-$(1): prepare-host-tools-$(1)
|
||||
|
||||
prepare-host-tools-$(1): \
|
||||
$$(foreach tool, $$(PREPARE_TOOLS), \
|
||||
$$(foreach host,$$(CFG_HOST), \
|
||||
prepare-host-tool-$$(tool)-$$(PREPARE_STAGE)-$$(host)-$(1)))
|
||||
|
||||
prepare-host-dirs-$(1): prepare-maybe-clean-$(1)
|
||||
$$(call PREPARE_DIR,$$(PREPARE_DEST_BIN_DIR))
|
||||
$$(call PREPARE_DIR,$$(PREPARE_DEST_LIB_DIR))
|
||||
$$(call PREPARE_DIR,$$(PREPARE_DEST_LIB_DIR)/rustlib/etc)
|
||||
$$(call PREPARE_DIR,$$(PREPARE_DEST_MAN_DIR))
|
||||
|
||||
prepare-debugger-scripts-$(1): prepare-host-dirs-$(1) \
|
||||
$$(DEBUGGER_BIN_SCRIPTS_ALL_ABS) \
|
||||
$$(DEBUGGER_RUSTLIB_ETC_SCRIPTS_ALL_ABS)
|
||||
$$(call INSTALL_DEBUGGER_SCRIPT_COMMANDS,$$(PREPARE_HOST))
|
||||
|
||||
$$(foreach tool,$$(PREPARE_TOOLS), \
|
||||
$$(foreach host,$$(CFG_HOST), \
|
||||
$$(eval $$(call DEF_PREPARE_HOST_TOOL,$$(tool),$$(PREPARE_STAGE),$$(host),$(1)))))
|
||||
|
||||
$$(foreach lib,$$(CRATES), \
|
||||
$$(foreach host,$$(CFG_HOST), \
|
||||
$$(eval $$(call DEF_PREPARE_HOST_LIB,$$(lib),$$(PREPARE_STAGE),$$(host),$(1)))))
|
||||
|
||||
prepare-target-$(1): \
|
||||
$$(foreach host,$$(CFG_HOST), \
|
||||
$$(foreach target,$$(CFG_TARGET), \
|
||||
prepare-target-$$(target)-host-$$(host)-$$(PREPARE_STAGE)-$(1)))
|
||||
|
||||
$$(foreach host,$$(CFG_HOST), \
|
||||
$$(foreach target,$$(CFG_TARGET), \
|
||||
$$(eval $$(call DEF_PREPARE_TARGET_N,$$(PREPARE_STAGE),$$(target),$$(host),$(1)))))
|
||||
|
||||
prepare-maybe-clean-$(1):
|
||||
$$(if $$(findstring true,$$(PREPARE_CLEAN)), \
|
||||
@$$(call E, cleaning destination $$(PREPARE_DEST_DIR)),)
|
||||
$$(if $$(findstring true,$$(PREPARE_CLEAN)), \
|
||||
$$(Q)rm -rf $$(PREPARE_DEST_DIR),)
|
||||
|
||||
|
||||
endef
|
||||
@ -1,43 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# Recursive wildcard function
|
||||
# http://blog.jgc.org/2011/07/gnu-make-recursive-wildcard-function.html
|
||||
rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) \
|
||||
$(filter $(subst *,%,$2),$d))
|
||||
|
||||
ifndef CFG_DISABLE_MANAGE_SUBMODULES
|
||||
# This is a pretty expensive operation but I don't see any way to avoid it
|
||||
# NB: This only looks for '+' status (wrong commit checked out), not '-' status
|
||||
# (nothing checked out at all). `./configure --{llvm,jemalloc}-root`
|
||||
# will explicitly deinitialize the corresponding submodules, and we don't
|
||||
# want to force constant rebuilds in that case.
|
||||
NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && $(CFG_GIT) submodule status | grep -c '^+')
|
||||
else
|
||||
NEED_GIT_RECONFIG=0
|
||||
endif
|
||||
|
||||
ifeq ($(NEED_GIT_RECONFIG),0)
|
||||
else
|
||||
# If the submodules have changed then always execute config.mk
|
||||
.PHONY: config.stamp
|
||||
endif
|
||||
|
||||
Makefile config.mk: config.stamp
|
||||
|
||||
ifeq ($(SREL),)
|
||||
SREL_ROOT := ./
|
||||
else
|
||||
SREL_ROOT := $(SREL)
|
||||
endif
|
||||
|
||||
config.stamp: $(S)configure $(S)Makefile.in $(S)src/stage0.txt
|
||||
@$(call E, cfg: reconfiguring)
|
||||
$(SREL_ROOT)configure $(CFG_CONFIGURE_ARGS)
|
||||
721
mk/rt.mk
721
mk/rt.mk
@ -1,721 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
################################################################################
|
||||
# Native libraries built as part of the rust build process
|
||||
#
|
||||
# This portion of the rust build system is meant to keep track of native
|
||||
# dependencies and how to build them. It is currently required that all native
|
||||
# dependencies are built as static libraries, as slinging around dynamic
|
||||
# libraries isn't exactly the most fun thing to do.
|
||||
#
|
||||
# This section should need minimal modification to add new libraries. The
|
||||
# relevant variables are:
|
||||
#
|
||||
# NATIVE_LIBS
|
||||
# This is a list of all native libraries which are built as part of the
|
||||
# build process. It will build all libraries into RT_OUTPUT_DIR with the
|
||||
# appropriate name of static library as dictated by the target platform
|
||||
#
|
||||
# NATIVE_DEPS_<lib>
|
||||
# This is a list of files relative to the src/rt directory which are
|
||||
# needed to build the native library. Each file will be compiled to an
|
||||
# object file, and then all the object files will be assembled into an
|
||||
# archive (static library). The list contains files of any extension
|
||||
#
|
||||
# If adding a new library, you should update the NATIVE_LIBS list, and then list
|
||||
# the required files below it. The list of required files is a list of files
|
||||
# that's per-target so you're allowed to conditionally add files based on the
|
||||
# target.
|
||||
################################################################################
|
||||
NATIVE_LIBS := hoedown miniz rust_test_helpers
|
||||
|
||||
# A macro to add a generic implementation of intrinsics iff a arch optimized implementation is not
|
||||
# already in the list.
|
||||
# $(1) is the target
|
||||
# $(2) is the intrinsic
|
||||
define ADD_INTRINSIC
|
||||
ifeq ($$(findstring X,$$(foreach intrinsic,$$(COMPRT_OBJS_$(1)),$$(if $$(findstring $(2),$$(intrinsic)),X,))),)
|
||||
COMPRT_OBJS_$(1) += $(2)
|
||||
endif
|
||||
endef
|
||||
|
||||
# $(1) is the target triple
|
||||
define NATIVE_LIBRARIES
|
||||
|
||||
NATIVE_DEPS_hoedown_$(1) := hoedown/src/autolink.c \
|
||||
hoedown/src/buffer.c \
|
||||
hoedown/src/document.c \
|
||||
hoedown/src/escape.c \
|
||||
hoedown/src/html.c \
|
||||
hoedown/src/html_blocks.c \
|
||||
hoedown/src/html_smartypants.c \
|
||||
hoedown/src/stack.c \
|
||||
hoedown/src/version.c
|
||||
NATIVE_DEPS_miniz_$(1) = miniz.c
|
||||
NATIVE_DEPS_rust_test_helpers_$(1) := rust_test_helpers.c
|
||||
|
||||
################################################################################
|
||||
# You shouldn't find it that necessary to edit anything below this line.
|
||||
################################################################################
|
||||
|
||||
# While we're defining the native libraries for each target, we define some
|
||||
# common rules used to build files for various targets.
|
||||
|
||||
RT_OUTPUT_DIR_$(1) := $(1)/rt
|
||||
|
||||
$$(RT_OUTPUT_DIR_$(1))/%.o: $(S)src/rt/%.c $$(MKFILE_DEPS)
|
||||
@mkdir -p $$(@D)
|
||||
@$$(call E, compile: $$@)
|
||||
$$(Q)$$(call CFG_COMPILE_C_$(1), $$@, \
|
||||
$$(call CFG_CC_INCLUDE_$(1),$$(S)src/rt/hoedown/src) \
|
||||
$$(call CFG_CC_INCLUDE_$(1),$$(S)src/rt) \
|
||||
$$(RUNTIME_CFLAGS_$(1))) $$<
|
||||
|
||||
$$(RT_OUTPUT_DIR_$(1))/%.o: $(S)src/rt/%.S $$(MKFILE_DEPS) \
|
||||
$$(LLVM_CONFIG_$$(CFG_BUILD))
|
||||
@mkdir -p $$(@D)
|
||||
@$$(call E, compile: $$@)
|
||||
$$(Q)$$(call CFG_ASSEMBLE_$(1),$$@,$$<)
|
||||
|
||||
# On MSVC targets the compiler's default include path (e.g. where to find system
|
||||
# headers) is specified by the INCLUDE environment variable. This may not be set
|
||||
# so the ./configure script scraped the relevant values and this is the location
|
||||
# that we put them into cl.exe's environment.
|
||||
ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
$$(RT_OUTPUT_DIR_$(1))/%.o: \
|
||||
export INCLUDE := $$(CFG_MSVC_INCLUDE_PATH_$$(HOST_$(1)))
|
||||
$(1)/rustllvm/%.o: \
|
||||
export INCLUDE := $$(CFG_MSVC_INCLUDE_PATH_$$(HOST_$(1)))
|
||||
endif
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET),$(eval $(call NATIVE_LIBRARIES,$(target))))
|
||||
|
||||
# A macro for devining how to build third party libraries listed above (based
|
||||
# on their dependencies).
|
||||
#
|
||||
# $(1) is the target
|
||||
# $(2) is the lib name
|
||||
define THIRD_PARTY_LIB
|
||||
|
||||
OBJS_$(2)_$(1) := $$(NATIVE_DEPS_$(2)_$(1):%=$$(RT_OUTPUT_DIR_$(1))/%)
|
||||
OBJS_$(2)_$(1) := $$(OBJS_$(2)_$(1):.c=.o)
|
||||
OBJS_$(2)_$(1) := $$(OBJS_$(2)_$(1):.cpp=.o)
|
||||
OBJS_$(2)_$(1) := $$(OBJS_$(2)_$(1):.S=.o)
|
||||
NATIVE_$(2)_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),$(2))
|
||||
$$(RT_OUTPUT_DIR_$(1))/$$(NATIVE_$(2)_$(1)): $$(OBJS_$(2)_$(1))
|
||||
@$$(call E, link: $$@)
|
||||
$$(Q)$$(call CFG_CREATE_ARCHIVE_$(1),$$@) $$^
|
||||
|
||||
endef
|
||||
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call RUNTIME_RULES,$(target))))
|
||||
$(foreach lib,$(NATIVE_LIBS), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call THIRD_PARTY_LIB,$(target),$(lib)))))
|
||||
|
||||
|
||||
################################################################################
|
||||
# Building third-party targets with external build systems
|
||||
#
|
||||
# This location is meant for dependencies which have external build systems. It
|
||||
# is still assumed that the output of each of these steps is a static library
|
||||
# in the correct location.
|
||||
################################################################################
|
||||
|
||||
define DEF_THIRD_PARTY_TARGETS
|
||||
|
||||
# $(1) is the target triple
|
||||
|
||||
ifeq ($$(CFG_WINDOWSY_$(1)),1)
|
||||
# A bit of history here, this used to be --enable-lazy-lock added in #14006
|
||||
# which was filed with jemalloc in jemalloc/jemalloc#83 which was also
|
||||
# reported to MinGW: http://sourceforge.net/p/mingw-w64/bugs/395/
|
||||
#
|
||||
# When updating jemalloc to 4.0, however, it was found that binaries would
|
||||
# exit with the status code STATUS_RESOURCE_NOT_OWNED indicating that a thread
|
||||
# was unlocking a mutex it never locked. Disabling this "lazy lock" option
|
||||
# seems to fix the issue, but it was enabled by default for MinGW targets in
|
||||
# 13473c7 for jemalloc.
|
||||
#
|
||||
# As a result of all that, force disabling lazy lock on Windows, and after
|
||||
# reading some code it at least *appears* that the initialization of mutexes
|
||||
# is otherwise ok in jemalloc, so shouldn't cause problems hopefully...
|
||||
#
|
||||
# tl;dr: make windows behave like other platforms by disabling lazy locking,
|
||||
# but requires passing an option due to a historical default with
|
||||
# jemalloc.
|
||||
JEMALLOC_ARGS_$(1) := --disable-lazy-lock
|
||||
else ifeq ($(OSTYPE_$(1)), apple-ios)
|
||||
JEMALLOC_ARGS_$(1) := --disable-tls
|
||||
else ifeq ($(findstring android, $(OSTYPE_$(1))), android)
|
||||
# We force android to have prefixed symbols because apparently replacement of
|
||||
# the libc allocator doesn't quite work. When this was tested (unprefixed
|
||||
# symbols), it was found that the `realpath` function in libc would allocate
|
||||
# with libc malloc (not jemalloc malloc), and then the standard library would
|
||||
# free with jemalloc free, causing a segfault.
|
||||
#
|
||||
# If the test suite passes, however, without symbol prefixes then we should be
|
||||
# good to go!
|
||||
JEMALLOC_ARGS_$(1) := --disable-tls --with-jemalloc-prefix=je_
|
||||
else ifeq ($(findstring dragonfly, $(OSTYPE_$(1))), dragonfly)
|
||||
JEMALLOC_ARGS_$(1) := --with-jemalloc-prefix=je_
|
||||
endif
|
||||
|
||||
ifdef CFG_ENABLE_DEBUG_JEMALLOC
|
||||
JEMALLOC_ARGS_$(1) += --enable-debug --enable-fill
|
||||
endif
|
||||
|
||||
################################################################################
|
||||
# jemalloc
|
||||
################################################################################
|
||||
|
||||
ifdef CFG_ENABLE_FAST_MAKE
|
||||
JEMALLOC_DEPS := $(S)/.gitmodules
|
||||
else
|
||||
JEMALLOC_DEPS := $(wildcard \
|
||||
$(S)src/jemalloc/* \
|
||||
$(S)src/jemalloc/*/* \
|
||||
$(S)src/jemalloc/*/*/* \
|
||||
$(S)src/jemalloc/*/*/*/*)
|
||||
endif
|
||||
|
||||
# See #17183 for details, this file is touched during the build process so we
|
||||
# don't want to consider it as a dependency.
|
||||
JEMALLOC_DEPS := $(filter-out $(S)src/jemalloc/VERSION,$(JEMALLOC_DEPS))
|
||||
|
||||
JEMALLOC_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),jemalloc)
|
||||
ifeq ($$(CFG_WINDOWSY_$(1)),1)
|
||||
JEMALLOC_REAL_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),jemalloc_s)
|
||||
else
|
||||
JEMALLOC_REAL_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),jemalloc_pic)
|
||||
endif
|
||||
JEMALLOC_LIB_$(1) := $$(RT_OUTPUT_DIR_$(1))/$$(JEMALLOC_NAME_$(1))
|
||||
JEMALLOC_BUILD_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/jemalloc
|
||||
JEMALLOC_LOCAL_$(1) := $$(JEMALLOC_BUILD_DIR_$(1))/lib/$$(JEMALLOC_REAL_NAME_$(1))
|
||||
|
||||
$$(JEMALLOC_LOCAL_$(1)): $$(JEMALLOC_DEPS) $$(MKFILE_DEPS)
|
||||
@$$(call E, make: jemalloc)
|
||||
cd "$$(JEMALLOC_BUILD_DIR_$(1))"; "$(S)src/jemalloc/configure" \
|
||||
$$(JEMALLOC_ARGS_$(1)) $(CFG_JEMALLOC_FLAGS) \
|
||||
--build=$$(CFG_GNU_TRIPLE_$(CFG_BUILD)) --host=$$(CFG_GNU_TRIPLE_$(1)) \
|
||||
CC="$$(CC_$(1)) $$(CFG_JEMALLOC_CFLAGS_$(1))" \
|
||||
AR="$$(AR_$(1))" \
|
||||
RANLIB="$$(AR_$(1)) s" \
|
||||
CPPFLAGS="-I $(S)src/rt/" \
|
||||
EXTRA_CFLAGS="-g1 -ffunction-sections -fdata-sections"
|
||||
$$(Q)$$(MAKE) -C "$$(JEMALLOC_BUILD_DIR_$(1))" build_lib_static
|
||||
|
||||
ifeq ($(1),$$(CFG_BUILD))
|
||||
ifneq ($$(CFG_JEMALLOC_ROOT),)
|
||||
$$(JEMALLOC_LIB_$(1)): $$(CFG_JEMALLOC_ROOT)/libjemalloc_pic.a
|
||||
@$$(call E, copy: jemalloc)
|
||||
$$(Q)cp $$< $$@
|
||||
else
|
||||
$$(JEMALLOC_LIB_$(1)): $$(JEMALLOC_LOCAL_$(1))
|
||||
$$(Q)cp $$< $$@
|
||||
endif
|
||||
else
|
||||
$$(JEMALLOC_LIB_$(1)): $$(JEMALLOC_LOCAL_$(1))
|
||||
$$(Q)cp $$< $$@
|
||||
endif
|
||||
|
||||
################################################################################
|
||||
# compiler-rt
|
||||
################################################################################
|
||||
|
||||
# Everything below is a manual compilation of compiler-rt, disregarding its
|
||||
# build system. See comments in `src/bootstrap/native.rs` for more information.
|
||||
|
||||
COMPRT_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),compiler-rt)
|
||||
COMPRT_LIB_$(1) := $$(RT_OUTPUT_DIR_$(1))/$$(COMPRT_NAME_$(1))
|
||||
COMPRT_BUILD_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/compiler-rt
|
||||
|
||||
# We must avoid compiling both a generic implementation (e.g. `floatdidf.c) and an arch optimized
|
||||
# implementation (e.g. `x86_64/floatdidf.S) of the same symbol (e.g. `floatdidf) because that causes
|
||||
# linker errors. To avoid that, we first add all the arch optimized implementations and then add the
|
||||
# generic implementations if and only if its arch optimized version is not already in the list. This
|
||||
# last part is handled by the ADD_INTRINSIC macro.
|
||||
|
||||
COMPRT_OBJS_$(1) :=
|
||||
|
||||
ifeq ($$(findstring msvc,$(1)),)
|
||||
ifeq ($$(findstring x86_64,$(1)),x86_64)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
x86_64/chkstk.o \
|
||||
x86_64/chkstk2.o \
|
||||
x86_64/floatdidf.o \
|
||||
x86_64/floatdisf.o \
|
||||
x86_64/floatdixf.o \
|
||||
x86_64/floatundidf.o \
|
||||
x86_64/floatundisf.o \
|
||||
x86_64/floatundixf.o
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring i686,$$(patsubts i%86,i686,$(1))),i686)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
i386/ashldi3.o \
|
||||
i386/ashrdi3.o \
|
||||
i386/chkstk.o \
|
||||
i386/chkstk2.o \
|
||||
i386/divdi3.o \
|
||||
i386/floatdidf.o \
|
||||
i386/floatdisf.o \
|
||||
i386/floatdixf.o \
|
||||
i386/floatundidf.o \
|
||||
i386/floatundisf.o \
|
||||
i386/floatundixf.o \
|
||||
i386/lshrdi3.o \
|
||||
i386/moddi3.o \
|
||||
i386/muldi3.o \
|
||||
i386/udivdi3.o \
|
||||
i386/umoddi3.o
|
||||
endif
|
||||
|
||||
else
|
||||
|
||||
ifeq ($$(findstring x86_64,$(1)),x86_64)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
x86_64/floatdidf.o \
|
||||
x86_64/floatdisf.o \
|
||||
x86_64/floatdixf.o
|
||||
endif
|
||||
|
||||
endif
|
||||
|
||||
# Generic ARM sources, nothing compiles on iOS though
|
||||
ifeq ($$(findstring arm,$(1)),arm)
|
||||
ifeq ($$(findstring ios,$(1)),)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
arm/aeabi_cdcmp.o \
|
||||
arm/aeabi_cdcmpeq_check_nan.o \
|
||||
arm/aeabi_cfcmp.o \
|
||||
arm/aeabi_cfcmpeq_check_nan.o \
|
||||
arm/aeabi_dcmp.o \
|
||||
arm/aeabi_div0.o \
|
||||
arm/aeabi_drsub.o \
|
||||
arm/aeabi_fcmp.o \
|
||||
arm/aeabi_frsub.o \
|
||||
arm/aeabi_idivmod.o \
|
||||
arm/aeabi_ldivmod.o \
|
||||
arm/aeabi_memcmp.o \
|
||||
arm/aeabi_memcpy.o \
|
||||
arm/aeabi_memmove.o \
|
||||
arm/aeabi_memset.o \
|
||||
arm/aeabi_uidivmod.o \
|
||||
arm/aeabi_uldivmod.o \
|
||||
arm/bswapdi2.o \
|
||||
arm/bswapsi2.o \
|
||||
arm/clzdi2.o \
|
||||
arm/clzsi2.o \
|
||||
arm/comparesf2.o \
|
||||
arm/divmodsi4.o \
|
||||
arm/divsi3.o \
|
||||
arm/modsi3.o \
|
||||
arm/switch16.o \
|
||||
arm/switch32.o \
|
||||
arm/switch8.o \
|
||||
arm/switchu8.o \
|
||||
arm/sync_synchronize.o \
|
||||
arm/udivmodsi4.o \
|
||||
arm/udivsi3.o \
|
||||
arm/umodsi3.o
|
||||
endif
|
||||
endif
|
||||
|
||||
# Thumb sources
|
||||
ifeq ($$(findstring armv7,$(1)),armv7)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
arm/sync_fetch_and_add_4.o \
|
||||
arm/sync_fetch_and_add_8.o \
|
||||
arm/sync_fetch_and_and_4.o \
|
||||
arm/sync_fetch_and_and_8.o \
|
||||
arm/sync_fetch_and_max_4.o \
|
||||
arm/sync_fetch_and_max_8.o \
|
||||
arm/sync_fetch_and_min_4.o \
|
||||
arm/sync_fetch_and_min_8.o \
|
||||
arm/sync_fetch_and_nand_4.o \
|
||||
arm/sync_fetch_and_nand_8.o \
|
||||
arm/sync_fetch_and_or_4.o \
|
||||
arm/sync_fetch_and_or_8.o \
|
||||
arm/sync_fetch_and_sub_4.o \
|
||||
arm/sync_fetch_and_sub_8.o \
|
||||
arm/sync_fetch_and_umax_4.o \
|
||||
arm/sync_fetch_and_umax_8.o \
|
||||
arm/sync_fetch_and_umin_4.o \
|
||||
arm/sync_fetch_and_umin_8.o \
|
||||
arm/sync_fetch_and_xor_4.o \
|
||||
arm/sync_fetch_and_xor_8.o
|
||||
endif
|
||||
|
||||
# VFP sources
|
||||
ifeq ($$(findstring eabihf,$(1)),eabihf)
|
||||
COMPRT_OBJS_$(1) += \
|
||||
arm/adddf3vfp.o \
|
||||
arm/addsf3vfp.o \
|
||||
arm/divdf3vfp.o \
|
||||
arm/divsf3vfp.o \
|
||||
arm/eqdf2vfp.o \
|
||||
arm/eqsf2vfp.o \
|
||||
arm/extendsfdf2vfp.o \
|
||||
arm/fixdfsivfp.o \
|
||||
arm/fixsfsivfp.o \
|
||||
arm/fixunsdfsivfp.o \
|
||||
arm/fixunssfsivfp.o \
|
||||
arm/floatsidfvfp.o \
|
||||
arm/floatsisfvfp.o \
|
||||
arm/floatunssidfvfp.o \
|
||||
arm/floatunssisfvfp.o \
|
||||
arm/gedf2vfp.o \
|
||||
arm/gesf2vfp.o \
|
||||
arm/gtdf2vfp.o \
|
||||
arm/gtsf2vfp.o \
|
||||
arm/ledf2vfp.o \
|
||||
arm/lesf2vfp.o \
|
||||
arm/ltdf2vfp.o \
|
||||
arm/ltsf2vfp.o \
|
||||
arm/muldf3vfp.o \
|
||||
arm/mulsf3vfp.o \
|
||||
arm/negdf2vfp.o \
|
||||
arm/negsf2vfp.o \
|
||||
arm/nedf2vfp.o \
|
||||
arm/nesf2vfp.o \
|
||||
arm/restore_vfp_d8_d15_regs.o \
|
||||
arm/save_vfp_d8_d15_regs.o \
|
||||
arm/subdf3vfp.o \
|
||||
arm/subsf3vfp.o \
|
||||
arm/truncdfsf2vfp.o \
|
||||
arm/unorddf2vfp.o \
|
||||
arm/unordsf2vfp.o
|
||||
endif
|
||||
|
||||
$(foreach intrinsic,absvdi2.o \
|
||||
absvsi2.o \
|
||||
adddf3.o \
|
||||
addsf3.o \
|
||||
addvdi3.o \
|
||||
addvsi3.o \
|
||||
apple_versioning.o \
|
||||
ashldi3.o \
|
||||
ashrdi3.o \
|
||||
clear_cache.o \
|
||||
clzdi2.o \
|
||||
clzsi2.o \
|
||||
cmpdi2.o \
|
||||
comparedf2.o \
|
||||
comparesf2.o \
|
||||
ctzdi2.o \
|
||||
ctzsi2.o \
|
||||
divdc3.o \
|
||||
divdf3.o \
|
||||
divdi3.o \
|
||||
divmoddi4.o \
|
||||
divmodsi4.o \
|
||||
divsc3.o \
|
||||
divsf3.o \
|
||||
divsi3.o \
|
||||
divxc3.o \
|
||||
extendsfdf2.o \
|
||||
extendhfsf2.o \
|
||||
ffsdi2.o \
|
||||
fixdfdi.o \
|
||||
fixdfsi.o \
|
||||
fixsfdi.o \
|
||||
fixsfsi.o \
|
||||
fixunsdfdi.o \
|
||||
fixunsdfsi.o \
|
||||
fixunssfdi.o \
|
||||
fixunssfsi.o \
|
||||
fixunsxfdi.o \
|
||||
fixunsxfsi.o \
|
||||
fixxfdi.o \
|
||||
floatdidf.o \
|
||||
floatdisf.o \
|
||||
floatdixf.o \
|
||||
floatsidf.o \
|
||||
floatsisf.o \
|
||||
floatundidf.o \
|
||||
floatundisf.o \
|
||||
floatundixf.o \
|
||||
floatunsidf.o \
|
||||
floatunsisf.o \
|
||||
int_util.o \
|
||||
lshrdi3.o \
|
||||
moddi3.o \
|
||||
modsi3.o \
|
||||
muldc3.o \
|
||||
muldf3.o \
|
||||
muldi3.o \
|
||||
mulodi4.o \
|
||||
mulosi4.o \
|
||||
muloti4.o \
|
||||
mulsc3.o \
|
||||
mulsf3.o \
|
||||
mulvdi3.o \
|
||||
mulvsi3.o \
|
||||
mulxc3.o \
|
||||
negdf2.o \
|
||||
negdi2.o \
|
||||
negsf2.o \
|
||||
negvdi2.o \
|
||||
negvsi2.o \
|
||||
paritydi2.o \
|
||||
paritysi2.o \
|
||||
popcountdi2.o \
|
||||
popcountsi2.o \
|
||||
powidf2.o \
|
||||
powisf2.o \
|
||||
powixf2.o \
|
||||
subdf3.o \
|
||||
subsf3.o \
|
||||
subvdi3.o \
|
||||
subvsi3.o \
|
||||
truncdfhf2.o \
|
||||
truncdfsf2.o \
|
||||
truncsfhf2.o \
|
||||
ucmpdi2.o \
|
||||
udivdi3.o \
|
||||
udivmoddi4.o \
|
||||
udivmodsi4.o \
|
||||
udivsi3.o \
|
||||
umoddi3.o \
|
||||
umodsi3.o,
|
||||
$(call ADD_INTRINSIC,$(1),$(intrinsic)))
|
||||
|
||||
ifeq ($$(findstring ios,$(1)),)
|
||||
$(foreach intrinsic,absvti2.o \
|
||||
addtf3.o \
|
||||
addvti3.o \
|
||||
ashlti3.o \
|
||||
ashrti3.o \
|
||||
clzti2.o \
|
||||
cmpti2.o \
|
||||
ctzti2.o \
|
||||
divtf3.o \
|
||||
divti3.o \
|
||||
ffsti2.o \
|
||||
fixdfti.o \
|
||||
fixsfti.o \
|
||||
fixunsdfti.o \
|
||||
fixunssfti.o \
|
||||
fixunsxfti.o \
|
||||
fixxfti.o \
|
||||
floattidf.o \
|
||||
floattisf.o \
|
||||
floattixf.o \
|
||||
floatuntidf.o \
|
||||
floatuntisf.o \
|
||||
floatuntixf.o \
|
||||
lshrti3.o \
|
||||
modti3.o \
|
||||
multf3.o \
|
||||
multi3.o \
|
||||
mulvti3.o \
|
||||
negti2.o \
|
||||
negvti2.o \
|
||||
parityti2.o \
|
||||
popcountti2.o \
|
||||
powitf2.o \
|
||||
subtf3.o \
|
||||
subvti3.o \
|
||||
trampoline_setup.o \
|
||||
ucmpti2.o \
|
||||
udivmodti4.o \
|
||||
udivti3.o \
|
||||
umodti3.o,
|
||||
$(call ADD_INTRINSIC,$(1),$(intrinsic)))
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring apple,$(1)),apple)
|
||||
$(foreach intrinsic,atomic_flag_clear.o \
|
||||
atomic_flag_clear_explicit.o \
|
||||
atomic_flag_test_and_set.o \
|
||||
atomic_flag_test_and_set_explicit.o \
|
||||
atomic_signal_fence.o \
|
||||
atomic_thread_fence.o,
|
||||
$(call ADD_INTRINSIC,$(1),$(intrinsic)))
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring windows,$(1)),)
|
||||
$(call ADD_INTRINSIC,$(1),emutls.o)
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring msvc,$(1)),)
|
||||
|
||||
ifeq ($$(findstring freebsd,$(1)),)
|
||||
ifeq ($$(findstring netbsd,$(1)),)
|
||||
$(call ADD_INTRINSIC,$(1),gcc_personality_v0.o)
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring aarch64,$(1)),aarch64)
|
||||
$(foreach intrinsic,comparetf2.o \
|
||||
extenddftf2.o \
|
||||
extendsftf2.o \
|
||||
fixtfdi.o \
|
||||
fixtfsi.o \
|
||||
fixtfti.o \
|
||||
fixunstfdi.o \
|
||||
fixunstfsi.o \
|
||||
fixunstfti.o \
|
||||
floatditf.o \
|
||||
floatsitf.o \
|
||||
floatunditf.o \
|
||||
floatunsitf.o \
|
||||
multc3.o \
|
||||
trunctfdf2.o \
|
||||
trunctfsf2.o,
|
||||
$(call ADD_INTRINSIC,$(1),$(intrinsic)))
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
$$(COMPRT_BUILD_DIR_$(1))/%.o: CFLAGS += -Zl -D__func__=__FUNCTION__
|
||||
else
|
||||
$$(COMPRT_BUILD_DIR_$(1))/%.o: CFLAGS += -fno-builtin -fvisibility=hidden \
|
||||
-fomit-frame-pointer -ffreestanding
|
||||
endif
|
||||
|
||||
COMPRT_OBJS_$(1) := $$(COMPRT_OBJS_$(1):%=$$(COMPRT_BUILD_DIR_$(1))/%)
|
||||
|
||||
$$(COMPRT_BUILD_DIR_$(1))/%.o: $(S)src/compiler-rt/lib/builtins/%.c
|
||||
@mkdir -p $$(@D)
|
||||
@$$(call E, compile: $$@)
|
||||
$$(Q)$$(call CFG_COMPILE_C_$(1),$$@,$$<)
|
||||
|
||||
$$(COMPRT_BUILD_DIR_$(1))/%.o: $(S)src/compiler-rt/lib/builtins/%.S \
|
||||
$$(LLVM_CONFIG_$$(CFG_BUILD))
|
||||
@mkdir -p $$(@D)
|
||||
@$$(call E, compile: $$@)
|
||||
$$(Q)$$(call CFG_ASSEMBLE_$(1),$$@,$$<)
|
||||
|
||||
ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
$$(COMPRT_BUILD_DIR_$(1))/%.o: \
|
||||
export INCLUDE := $$(CFG_MSVC_INCLUDE_PATH_$$(HOST_$(1)))
|
||||
endif
|
||||
|
||||
ifeq ($$(findstring emscripten,$(1)),emscripten)
|
||||
# FIXME: emscripten doesn't use compiler-rt and can't build it without
|
||||
# further hacks
|
||||
COMPRT_OBJS_$(1) :=
|
||||
endif
|
||||
|
||||
$$(COMPRT_LIB_$(1)): $$(COMPRT_OBJS_$(1))
|
||||
@$$(call E, link: $$@)
|
||||
$$(Q)$$(call CFG_CREATE_ARCHIVE_$(1),$$@) $$^
|
||||
|
||||
################################################################################
|
||||
# libbacktrace
|
||||
#
|
||||
# We use libbacktrace on linux to get symbols in backtraces, but only on linux.
|
||||
# Elsewhere we use other system utilities, so this library is only built on
|
||||
# linux.
|
||||
################################################################################
|
||||
|
||||
BACKTRACE_NAME_$(1) := $$(call CFG_STATIC_LIB_NAME_$(1),backtrace)
|
||||
BACKTRACE_LIB_$(1) := $$(RT_OUTPUT_DIR_$(1))/$$(BACKTRACE_NAME_$(1))
|
||||
BACKTRACE_BUILD_DIR_$(1) := $$(RT_OUTPUT_DIR_$(1))/libbacktrace
|
||||
|
||||
# We don't use this on platforms that aren't linux-based (with the exception of
|
||||
# msys2/mingw builds on windows, which use it to read the dwarf debug
|
||||
# information) so just make the file available, the compilation of libstd won't
|
||||
# actually build it.
|
||||
ifeq ($$(findstring darwin,$$(OSTYPE_$(1))),darwin)
|
||||
# See comment above
|
||||
$$(BACKTRACE_LIB_$(1)):
|
||||
touch $$@
|
||||
|
||||
else ifeq ($$(findstring ios,$$(OSTYPE_$(1))),ios)
|
||||
# See comment above
|
||||
$$(BACKTRACE_LIB_$(1)):
|
||||
touch $$@
|
||||
else ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
# See comment above
|
||||
$$(BACKTRACE_LIB_$(1)):
|
||||
touch $$@
|
||||
else ifeq ($$(findstring emscripten,$(1)),emscripten)
|
||||
# FIXME: libbacktrace doesn't understand the emscripten triple
|
||||
$$(BACKTRACE_LIB_$(1)):
|
||||
touch $$@
|
||||
else
|
||||
|
||||
ifdef CFG_ENABLE_FAST_MAKE
|
||||
BACKTRACE_DEPS := $(S)/.gitmodules
|
||||
else
|
||||
BACKTRACE_DEPS := $(wildcard $(S)src/libbacktrace/*)
|
||||
endif
|
||||
|
||||
# We need to export CFLAGS because otherwise it doesn't pick up cross compile
|
||||
# builds. If libbacktrace doesn't realize this, it will attempt to read 64-bit
|
||||
# elf headers when compiled for a 32-bit system, yielding blank backtraces.
|
||||
#
|
||||
# This also removes the -Werror flag specifically to prevent errors during
|
||||
# configuration.
|
||||
#
|
||||
# Down below you'll also see echos into the config.h generated by the
|
||||
# ./configure script. This is done to force libbacktrace to *not* use the
|
||||
# atomic/sync functionality because it pulls in unnecessary dependencies and we
|
||||
# never use it anyway.
|
||||
#
|
||||
# We also use `env PWD=` to clear the PWD environment variable, and then
|
||||
# execute the command in a new shell. This is necessary to workaround a
|
||||
# buildbot/msys2 bug: the shell is launched with PWD set to a windows-style path,
|
||||
# which results in all further uses of `pwd` also printing a windows-style path,
|
||||
# which breaks libbacktrace's configure script. Clearing PWD within the same
|
||||
# shell is not sufficient.
|
||||
|
||||
$$(BACKTRACE_BUILD_DIR_$(1))/Makefile: $$(BACKTRACE_DEPS) $$(MKFILE_DEPS)
|
||||
@$$(call E, configure: libbacktrace for $(1))
|
||||
$$(Q)rm -rf $$(BACKTRACE_BUILD_DIR_$(1))
|
||||
$$(Q)mkdir -p $$(BACKTRACE_BUILD_DIR_$(1))
|
||||
$$(Q)(cd $$(BACKTRACE_BUILD_DIR_$(1)) && env \
|
||||
PWD= \
|
||||
CC="$$(CC_$(1))" \
|
||||
AR="$$(AR_$(1))" \
|
||||
RANLIB="$$(AR_$(1)) s" \
|
||||
CFLAGS="$$(CFG_GCCISH_CFLAGS_$(1)) -Wno-error -fno-stack-protector" \
|
||||
$(S)src/libbacktrace/configure --build=$(CFG_GNU_TRIPLE_$(CFG_BUILD)) --host=$(CFG_GNU_TRIPLE_$(1)))
|
||||
$$(Q)echo '#undef HAVE_ATOMIC_FUNCTIONS' >> \
|
||||
$$(BACKTRACE_BUILD_DIR_$(1))/config.h
|
||||
$$(Q)echo '#undef HAVE_SYNC_FUNCTIONS' >> \
|
||||
$$(BACKTRACE_BUILD_DIR_$(1))/config.h
|
||||
|
||||
$$(BACKTRACE_LIB_$(1)): $$(BACKTRACE_BUILD_DIR_$(1))/Makefile $$(MKFILE_DEPS)
|
||||
@$$(call E, make: libbacktrace)
|
||||
$$(Q)$$(MAKE) -C $$(BACKTRACE_BUILD_DIR_$(1)) \
|
||||
INCDIR=$(S)src/libbacktrace
|
||||
$$(Q)cp $$(BACKTRACE_BUILD_DIR_$(1))/.libs/libbacktrace.a $$@
|
||||
|
||||
endif
|
||||
|
||||
################################################################################
|
||||
# libc/libunwind for musl
|
||||
#
|
||||
# When we're building a musl-like target we're going to link libc/libunwind
|
||||
# statically into the standard library and liblibc, so we need to make sure
|
||||
# they're in a location that we can find
|
||||
################################################################################
|
||||
|
||||
ifeq ($$(findstring musl,$(1)),musl)
|
||||
$$(RT_OUTPUT_DIR_$(1))/%: $$(CFG_MUSL_ROOT)/lib/%
|
||||
cp $$^ $$@
|
||||
else
|
||||
# Ask gcc where it is
|
||||
$$(RT_OUTPUT_DIR_$(1))/%:
|
||||
cp $$(shell $$(CC_$(1)) -print-file-name=$$(@F)) $$@
|
||||
endif
|
||||
|
||||
endef
|
||||
|
||||
# Instantiate template for all stages/targets
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call DEF_THIRD_PARTY_TARGETS,$(target))))
|
||||
@ -1,71 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
######################################################################
|
||||
# rustc LLVM-extensions (C++) library variables and rules
|
||||
######################################################################
|
||||
|
||||
define DEF_RUSTLLVM_TARGETS
|
||||
|
||||
# FIXME: Lately, on windows, llvm-config --includedir is not enough
|
||||
# to find the llvm includes (probably because we're not actually installing
|
||||
# llvm, but using it straight out of the build directory)
|
||||
ifdef CFG_WINDOWSY_$(1)
|
||||
LLVM_EXTRA_INCDIRS_$(1)= $$(call CFG_CC_INCLUDE_$(1),$(S)src/llvm/include) \
|
||||
$$(call CFG_CC_INCLUDE_$(1),\
|
||||
$$(CFG_LLVM_BUILD_DIR_$(1))/include)
|
||||
endif
|
||||
|
||||
RUSTLLVM_OBJS_CS_$(1) := $$(addprefix rustllvm/, \
|
||||
RustWrapper.cpp PassWrapper.cpp \
|
||||
ArchiveWrapper.cpp)
|
||||
|
||||
RUSTLLVM_INCS_$(1) = $$(LLVM_EXTRA_INCDIRS_$(1)) \
|
||||
$$(call CFG_CC_INCLUDE_$(1),$$(LLVM_INCDIR_$(1))) \
|
||||
$$(call CFG_CC_INCLUDE_$(1),$$(S)src/rustllvm/include)
|
||||
RUSTLLVM_OBJS_OBJS_$(1) := $$(RUSTLLVM_OBJS_CS_$(1):rustllvm/%.cpp=$(1)/rustllvm/%.o)
|
||||
|
||||
# Flag that we are building with Rust's llvm fork
|
||||
ifeq ($(CFG_LLVM_ROOT),)
|
||||
RUSTLLVM_CXXFLAGS_$(1) := -DLLVM_RUSTLLVM
|
||||
endif
|
||||
|
||||
# Note that we appease `cl.exe` and its need for some sort of exception
|
||||
# handling flag with the `EHsc` argument here as well.
|
||||
ifeq ($$(findstring msvc,$(1)),msvc)
|
||||
EXTRA_RUSTLLVM_CXXFLAGS_$(1) := //EHsc
|
||||
endif
|
||||
|
||||
$$(RT_OUTPUT_DIR_$(1))/$$(call CFG_STATIC_LIB_NAME_$(1),rustllvm): \
|
||||
$$(RUSTLLVM_OBJS_OBJS_$(1))
|
||||
@$$(call E, link: $$@)
|
||||
$$(Q)$$(call CFG_CREATE_ARCHIVE_$(1),$$@) $$^
|
||||
|
||||
RUSTLLVM_COMPONENTS_$(1) = $$(shell echo $$(LLVM_ALL_COMPONENTS_$(1)) |\
|
||||
tr 'a-z-' 'A-Z_'| sed -e 's/^ //;s/\([^ ]*\)/\-DLLVM_COMPONENT_\1/g')
|
||||
|
||||
# On MSVC we need to double-escape arguments that llvm-config printed which
|
||||
# start with a '/'. The shell we're running in will auto-translate the argument
|
||||
# `/foo` to `C:/msys64/foo` but we really want it to be passed through as `/foo`
|
||||
# so the argument passed to our shell must be `//foo`.
|
||||
$(1)/rustllvm/%.o: $(S)src/rustllvm/%.cpp $$(MKFILE_DEPS) $$(LLVM_CONFIG_$(1))
|
||||
@$$(call E, compile: $$@)
|
||||
$$(Q)$$(call CFG_COMPILE_CXX_$(1), $$@,) \
|
||||
$$(subst /,//,$$(LLVM_CXXFLAGS_$(1))) \
|
||||
$$(RUSTLLVM_COMPONENTS_$(1)) \
|
||||
$$(RUSTLLVM_CXXFLAGS_$(1)) \
|
||||
$$(EXTRA_RUSTLLVM_CXXFLAGS_$(1)) \
|
||||
$$(RUSTLLVM_INCS_$(1)) \
|
||||
$$<
|
||||
endef
|
||||
|
||||
# Instantiate template for all stages
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(eval $(call DEF_RUSTLLVM_TARGETS,$(host))))
|
||||
49
mk/stage0.mk
49
mk/stage0.mk
@ -1,49 +0,0 @@
|
||||
# Extract the snapshot host compiler
|
||||
|
||||
$(HBIN0_H_$(CFG_BUILD))/:
|
||||
mkdir -p $@
|
||||
|
||||
# On windows these two are the same, so cause a redifinition warning
|
||||
ifneq ($(HBIN0_H_$(CFG_BUILD)),$(HLIB0_H_$(CFG_BUILD)))
|
||||
$(HLIB0_H_$(CFG_BUILD))/:
|
||||
mkdir -p $@
|
||||
endif
|
||||
|
||||
$(SNAPSHOT_RUSTC_POST_CLEANUP): \
|
||||
$(S)src/stage0.txt \
|
||||
$(S)src/etc/local_stage0.sh \
|
||||
$(S)src/etc/get-stage0.py $(MKFILE_DEPS) \
|
||||
| $(HBIN0_H_$(CFG_BUILD))/
|
||||
@$(call E, fetch: $@)
|
||||
ifdef CFG_ENABLE_LOCAL_RUST
|
||||
$(Q)$(S)src/etc/local_stage0.sh $(CFG_BUILD) $(CFG_LOCAL_RUST_ROOT) rustlib
|
||||
else
|
||||
$(Q)$(CFG_PYTHON) $(S)src/etc/get-stage0.py $(CFG_BUILD)
|
||||
endif
|
||||
$(Q)if [ -e "$@" ]; then touch "$@"; else echo "ERROR: snapshot $@ not found"; exit 1; fi
|
||||
|
||||
# For other targets, let the host build the target:
|
||||
|
||||
define BOOTSTRAP_STAGE0
|
||||
# $(1) target to bootstrap
|
||||
# $(2) stage to bootstrap from
|
||||
# $(3) target to bootstrap from
|
||||
|
||||
$(HBIN0_H_$(1))/:
|
||||
mkdir -p $@
|
||||
|
||||
$(HLIB0_H_$(1))/:
|
||||
mkdir -p $@
|
||||
|
||||
$$(HBIN0_H_$(1))/rustc$$(X_$(1)): \
|
||||
$$(TBIN$(2)_T_$(1)_H_$(3))/rustc$$(X_$(1)) \
|
||||
| $(HBIN0_H_$(1))/
|
||||
@$$(call E, cp: $$@)
|
||||
$$(Q)cp $$< $$@
|
||||
|
||||
endef
|
||||
|
||||
# Use stage1 to build other architectures: then you don't have to wait
|
||||
# for stage2, but you get the latest updates to the compiler source.
|
||||
$(foreach t,$(NON_BUILD_HOST), \
|
||||
$(eval $(call BOOTSTRAP_STAGE0,$(t),1,$(CFG_BUILD))))
|
||||
209
mk/target.mk
209
mk/target.mk
@ -1,209 +0,0 @@
|
||||
# Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
# This is the compile-time target-triple for the compiler. For the compiler at
|
||||
# runtime, this should be considered the host-triple. More explanation for why
|
||||
# this exists can be found on issue #2400
|
||||
export CFG_COMPILER_HOST_TRIPLE
|
||||
|
||||
# Used as defaults for the runtime ar and cc tools
|
||||
export CFG_DEFAULT_LINKER
|
||||
export CFG_DEFAULT_AR
|
||||
|
||||
# Macro that generates the full list of dependencies for a crate at a particular
|
||||
# stage/target/host tuple.
|
||||
#
|
||||
# $(1) - stage
|
||||
# $(2) - target
|
||||
# $(3) - host
|
||||
# $(4) crate
|
||||
define RUST_CRATE_FULLDEPS
|
||||
CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4) := \
|
||||
$$(CRATEFILE_$(4)) \
|
||||
$$(RSINPUTS_$(4)) \
|
||||
$$(foreach dep,$$(RUST_DEPS_$(4)_T_$(2)), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep)) \
|
||||
$$(foreach dep,$$(NATIVE_DEPS_$(4)), \
|
||||
$$(RT_OUTPUT_DIR_$(2))/$$(call CFG_STATIC_LIB_NAME_$(2),$$(dep))) \
|
||||
$$(foreach dep,$$(NATIVE_DEPS_$(4)_T_$(2)), \
|
||||
$$(RT_OUTPUT_DIR_$(2))/$$(dep))
|
||||
endef
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(foreach stage,$(STAGES), \
|
||||
$(foreach crate,$(CRATES), \
|
||||
$(eval $(call RUST_CRATE_FULLDEPS,$(stage),$(target),$(host),$(crate)))))))
|
||||
|
||||
# RUST_TARGET_STAGE_N template: This defines how target artifacts are built
|
||||
# for all stage/target architecture combinations. This is one giant rule which
|
||||
# works as follows:
|
||||
#
|
||||
# 1. The immediate dependencies are the rust source files
|
||||
# 2. Each rust crate dependency is listed (based on their stamp files),
|
||||
# as well as all native dependencies (listed in RT_OUTPUT_DIR)
|
||||
# 3. The stage (n-1) compiler is required through the TSREQ dependency
|
||||
# 4. When actually executing the rule, the first thing we do is to clean out
|
||||
# old libs and rlibs via the REMOVE_ALL_OLD_GLOB_MATCHES macro
|
||||
# 5. Finally, we get around to building the actual crate. It's just one
|
||||
# "small" invocation of the previous stage rustc. We use -L to
|
||||
# RT_OUTPUT_DIR so all the native dependencies are picked up.
|
||||
# Additionally, we pass in the llvm dir so rustc can link against it.
|
||||
# 6. Some cleanup is done (listing what was just built) if verbose is turned
|
||||
# on.
|
||||
#
|
||||
# $(1) is the stage
|
||||
# $(2) is the target triple
|
||||
# $(3) is the host triple
|
||||
# $(4) is the crate name
|
||||
define RUST_TARGET_STAGE_N
|
||||
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): CFG_COMPILER_HOST_TRIPLE = $(2)
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$(4): \
|
||||
$$(CRATEFILE_$(4)) \
|
||||
$$(CRATE_FULLDEPS_$(1)_T_$(2)_H_$(3)_$(4)) \
|
||||
$$(LLVM_CONFIG_$(2)) \
|
||||
$$(TSREQ$(1)_T_$(2)_H_$(3)) \
|
||||
| $$(TLIB$(1)_T_$(2)_H_$(3))/
|
||||
@$$(call E, rustc: $$(@D)/lib$(4))
|
||||
@touch $$@.start_time
|
||||
$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_LIB_GLOB_$(2),$(4)))
|
||||
$$(call REMOVE_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_RLIB_GLOB,$(4)))
|
||||
$(Q)CFG_LLVM_LINKAGE_FILE=$$(LLVM_LINKAGE_PATH_$(2)) \
|
||||
$$(subst @,,$$(STAGE$(1)_T_$(2)_H_$(3))) \
|
||||
$$(RUST_LIB_FLAGS_ST$(1)) \
|
||||
-L "$$(RT_OUTPUT_DIR_$(2))" \
|
||||
$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
|
||||
$$(LLVM_STDCPP_RUSTFLAGS_$(2)) \
|
||||
$$(RUSTFLAGS_$(4)) \
|
||||
$$(RUSTFLAGS$(1)_$(4)) \
|
||||
$$(RUSTFLAGS$(1)_$(4)_T_$(2)) \
|
||||
--out-dir $$(@D) \
|
||||
-C extra-filename=-$$(CFG_FILENAME_EXTRA) \
|
||||
-C metadata=$$(CFG_FILENAME_EXTRA) \
|
||||
$$<
|
||||
@touch -r $$@.start_time $$@ && rm $$@.start_time
|
||||
$$(call LIST_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_LIB_GLOB_$(2),$(4)))
|
||||
$$(call LIST_ALL_OLD_GLOB_MATCHES, \
|
||||
$$(dir $$@)$$(call CFG_RLIB_GLOB,$(4)))
|
||||
|
||||
endef
|
||||
|
||||
# Macro for building any tool as part of the rust compilation process. Each
|
||||
# tool is defined in crates.mk with a list of library dependencies as well as
|
||||
# the source file for the tool. Building each tool will also be passed '--cfg
|
||||
# <tool>' for usage in driver.rs
|
||||
#
|
||||
# This build rule is similar to the one found above, just tweaked for
|
||||
# locations and things.
|
||||
#
|
||||
# $(1) - stage
|
||||
# $(2) - target triple
|
||||
# $(3) - host triple
|
||||
# $(4) - name of the tool being built
|
||||
define TARGET_TOOL
|
||||
|
||||
$$(TBIN$(1)_T_$(2)_H_$(3))/$(4)$$(X_$(2)): \
|
||||
$$(TOOL_SOURCE_$(4)) \
|
||||
$$(TOOL_INPUTS_$(4)) \
|
||||
$$(foreach dep,$$(TOOL_DEPS_$(4)), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(dep)) \
|
||||
$$(TSREQ$(1)_T_$(2)_H_$(3)) \
|
||||
| $$(TBIN$(1)_T_$(2)_H_$(3))/
|
||||
@$$(call E, rustc: $$@)
|
||||
$$(STAGE$(1)_T_$(2)_H_$(3)) \
|
||||
$$(LLVM_LIBDIR_RUSTFLAGS_$(2)) \
|
||||
-o $$@ $$< --cfg $(4)
|
||||
|
||||
endef
|
||||
|
||||
# Macro for building runtime startup/shutdown object files;
|
||||
# these are Rust's equivalent of crti.o, crtn.o
|
||||
#
|
||||
# $(1) - stage
|
||||
# $(2) - target triple
|
||||
# $(3) - host triple
|
||||
# $(4) - object basename
|
||||
define TARGET_RUSTRT_STARTUP_OBJ
|
||||
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/$(4).o: \
|
||||
$(S)src/rtstartup/$(4).rs \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.core \
|
||||
$$(HSREQ$(1)_T_$(2)_H_$(3)) \
|
||||
| $$(TBIN$(1)_T_$(2)_H_$(3))/
|
||||
@$$(call E, rustc: $$@)
|
||||
$$(STAGE$(1)_T_$(2)_H_$(3)) --emit=obj -o $$@ $$<
|
||||
|
||||
ifeq ($$(CFG_RUSTRT_HAS_STARTUP_OBJS_$(2)), 1)
|
||||
# Add dependencies on Rust startup objects to all crates that depend on core.
|
||||
# This ensures that they are built after core (since they depend on it),
|
||||
# but before everything else (since they are needed for linking dylib crates).
|
||||
$$(foreach crate, $$(TARGET_CRATES_$(2)), \
|
||||
$$(if $$(findstring core,$$(DEPS_$$(crate))), \
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/stamp.$$(crate))) : $$(TLIB$(1)_T_$(2)_H_$(3))/$(4).o
|
||||
endif
|
||||
|
||||
endef
|
||||
|
||||
# Every recipe in RUST_TARGET_STAGE_N outputs to $$(TLIB$(1)_T_$(2)_H_$(3),
|
||||
# a directory that can be cleaned out during the middle of a run of
|
||||
# the get-snapshot.py script. Therefore, every recipe needs to have
|
||||
# an order-only dependency either on $(SNAPSHOT_RUSTC_POST_CLEANUP) or
|
||||
# on $$(TSREQ$(1)_T_$(2)_H_$(3)), to ensure that no products will be
|
||||
# put into the target area until after the get-snapshot.py script has
|
||||
# had its chance to clean it out; otherwise the other products will be
|
||||
# inadvertently included in the clean out.
|
||||
SNAPSHOT_RUSTC_POST_CLEANUP=$(HBIN0_H_$(CFG_BUILD))/rustc$(X_$(CFG_BUILD))
|
||||
|
||||
define TARGET_HOST_RULES
|
||||
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/: $$(SNAPSHOT_RUSTC_POST_CLEANUP)
|
||||
mkdir -p $$@
|
||||
|
||||
$$(TBIN$(1)_T_$(2)_H_$(3))/: $$(SNAPSHOT_RUSTC_POST_CLEANUP)
|
||||
mkdir -p $$@
|
||||
|
||||
$$(TLIB$(1)_T_$(2)_H_$(3))/%: $$(RT_OUTPUT_DIR_$(2))/% \
|
||||
$$(SNAPSHOT_RUSTC_POST_CLEANUP) \
|
||||
| $$(TLIB$(1)_T_$(2)_H_$(3))/
|
||||
@$$(call E, cp: $$@)
|
||||
$$(Q)cp $$< $$@
|
||||
endef
|
||||
|
||||
$(foreach source,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call TARGET_HOST_RULES,0,$(target),$(source))) \
|
||||
$(eval $(call TARGET_HOST_RULES,1,$(target),$(source))) \
|
||||
$(eval $(call TARGET_HOST_RULES,2,$(target),$(source))) \
|
||||
$(eval $(call TARGET_HOST_RULES,3,$(target),$(source)))))
|
||||
|
||||
# In principle, each host can build each target for both libs and tools
|
||||
$(foreach crate,$(CRATES), \
|
||||
$(foreach source,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(eval $(call RUST_TARGET_STAGE_N,0,$(target),$(source),$(crate))) \
|
||||
$(eval $(call RUST_TARGET_STAGE_N,1,$(target),$(source),$(crate))) \
|
||||
$(eval $(call RUST_TARGET_STAGE_N,2,$(target),$(source),$(crate))) \
|
||||
$(eval $(call RUST_TARGET_STAGE_N,3,$(target),$(source),$(crate))))))
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(foreach stage,$(STAGES), \
|
||||
$(foreach tool,$(TOOLS), \
|
||||
$(eval $(call TARGET_TOOL,$(stage),$(target),$(host),$(tool)))))))
|
||||
|
||||
$(foreach host,$(CFG_HOST), \
|
||||
$(foreach target,$(CFG_TARGET), \
|
||||
$(foreach stage,$(STAGES), \
|
||||
$(foreach obj,rsbegin rsend, \
|
||||
$(eval $(call TARGET_RUSTRT_STARTUP_OBJ,$(stage),$(target),$(host),$(obj)))))))
|
||||
1057
mk/tests.mk
1057
mk/tests.mk
File diff suppressed because it is too large
Load Diff
23
mk/util.mk
23
mk/util.mk
@ -1,23 +0,0 @@
|
||||
# Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
# file at the top-level directory of this distribution and at
|
||||
# http://rust-lang.org/COPYRIGHT.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
# option. This file may not be copied, modified, or distributed
|
||||
# except according to those terms.
|
||||
|
||||
ifdef VERBOSE
|
||||
Q :=
|
||||
E =
|
||||
else
|
||||
Q := @
|
||||
E = echo $(1)
|
||||
endif
|
||||
|
||||
print-%:
|
||||
@echo $*=$($*)
|
||||
|
||||
S := $(CFG_SRC_DIR)
|
||||
SREL := $(CFG_SRC_DIR_RELATIVE)
|
||||
Loading…
Reference in New Issue
Block a user