mk/platform.mk

   1 # Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
   2 # file at the top-level directory of this distribution and at
   3 # http://rust-lang.org/COPYRIGHT.
   4 #
   5 # Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 # http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 # <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 # option. This file may not be copied, modified, or distributed
   9 # except according to those terms.
  10
  11
  12 # Create variables HOST_<triple> containing the host part
  13 # of each target triple.  For example, the triple i686-darwin-macos
  14 # would create a variable HOST_i686-darwin-macos with the value
  15 # i386.
  16 define DEF_HOST_VAR
  17   HOST_$(1) = $(subst i686,i386,$(word 1,$(subst -, ,$(1))))
  18 endef
  19 $(foreach t,$(CFG_TARGET),$(eval $(call DEF_HOST_VAR,$(t))))
  20 $(foreach t,$(CFG_TARGET),$(info cfg: host for $(t) is $(HOST_$(t))))
  21
  22 # Ditto for OSTYPE
  23 define DEF_OSTYPE_VAR
  24   OSTYPE_$(1) = $(subst $(firstword $(subst -, ,$(1)))-,,$(1))
  25 endef
  26 $(foreach t,$(CFG_TARGET),$(eval $(call DEF_OSTYPE_VAR,$(t))))
  27 $(foreach t,$(CFG_TARGET),$(info cfg: os for $(t) is $(OSTYPE_$(t))))
  28
  29 # On Darwin, we need to run dsymutil so the debugging information ends
  30 # up in the right place.  On other platforms, it automatically gets
  31 # embedded into the executable, so use a no-op command.
  32 CFG_DSYMUTIL := true
  33
  34 # Hack: not sure how to test if a file exists in make other than this
  35 OS_SUPP = $(patsubst %,--suppressions=%, \
  36       $(wildcard $(CFG_SRC_DIR)src/etc/$(CFG_OSTYPE).supp*))
  37
  38 ifdef CFG_DISABLE_OPTIMIZE_CXX
  39   $(info cfg: disabling C++ optimization (CFG_DISABLE_OPTIMIZE_CXX))
  40   CFG_GCCISH_CFLAGS += -O0
  41 else
  42   CFG_GCCISH_CFLAGS += -O2
  43 endif
  44
  45 # The soname thing is for supporting a statically linked jemalloc.
  46 # see https://blog.mozilla.org/jseward/2012/06/05/valgrind-now-supports-jemalloc-builds-directly/
  47 ifdef CFG_VALGRIND
  48   CFG_VALGRIND += --error-exitcode=100 \
  49                   --fair-sched=try \
  50                   --quiet \
  51                   --soname-synonyms=somalloc=NONE \
  52                   --suppressions=$(CFG_SRC_DIR)src/etc/x86.supp \
  53                   $(OS_SUPP)
  54   ifdef CFG_ENABLE_HELGRIND
  55     CFG_VALGRIND += --tool=helgrind
  56   else
  57     CFG_VALGRIND += --tool=memcheck \
  58                     --leak-check=full
  59   endif
  60 endif
  61
  62 # If we actually want to run Valgrind on a given platform, set this variable
  63 define DEF_GOOD_VALGRIND
  64   ifeq ($(OSTYPE_$(1)),unknown-linux-gnu)
  65     GOOD_VALGRIND_$(1) = 1
  66   endif
  67   ifneq (,$(filter $(OSTYPE_$(1)),darwin freebsd))
  68     ifeq (HOST_$(1),x86_64)
  69       GOOD_VALGRIND_$(1) = 1
  70     endif
  71   endif
  72 endef
  73 $(foreach t,$(CFG_TARGET),$(eval $(call DEF_GOOD_VALGRIND,$(t))))
  74 $(foreach t,$(CFG_TARGET),$(info cfg: good valgrind for $(t) is $(GOOD_VALGRIND_$(t))))
  75
  76 ifneq ($(findstring linux,$(CFG_OSTYPE)),)
  77   ifdef CFG_PERF
  78     ifneq ($(CFG_PERF_WITH_LOGFD),)
  79         CFG_PERF_TOOL := $(CFG_PERF) stat -r 3 --log-fd 2
  80     else
  81         CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
  82     endif
  83   else
  84     ifdef CFG_VALGRIND
  85       CFG_PERF_TOOL := \
  86         $(CFG_VALGRIND) --tool=cachegrind --cache-sim=yes --branch-sim=yes
  87     else
  88       CFG_PERF_TOOL := /usr/bin/time --verbose
  89     endif
  90   endif
  91 endif
  92
  93 AR := ar
  94
  95 define SET_FROM_CFG
  96   ifdef CFG_$(1)
  97     ifeq ($(origin $(1)),undefined)
  98       $$(info cfg: using $(1)=$(CFG_$(1)) (CFG_$(1)))
  99       $(1)=$(CFG_$(1))
 100     endif
 101     ifeq ($(origin $(1)),default)
 102       $$(info cfg: using $(1)=$(CFG_$(1)) (CFG_$(1)))
 103       $(1)=$(CFG_$(1))
 104     endif
 105   endif
 106 endef
 107
 108 $(foreach cvar,CC CXX CPP CFLAGS CXXFLAGS CPPFLAGS, \
 109   $(eval $(call SET_FROM_CFG,$(cvar))))
 110
 111 CFG_RLIB_GLOB=lib$(1)-*.rlib
 112
 113 include $(wildcard $(CFG_SRC_DIR)mk/cfg/*.mk)
 114
 115 define ADD_INSTALLED_OBJECTS
 116   INSTALLED_OBJECTS_$(1) += $$(call CFG_STATIC_LIB_NAME_$(1),morestack) \
 117                             $$(call CFG_STATIC_LIB_NAME_$(1),compiler-rt)
 118 endef
 119
 120 $(foreach target,$(CFG_TARGET), \
 121   $(eval $(call ADD_INSTALLED_OBJECTS,$(target))))
 122
 123 define DEFINE_LINKER
 124   ifndef LINK_$(1)
 125     LINK_$(1) := $$(CC_$(1))
 126   endif
 127 endef
 128
 129 $(foreach target,$(CFG_TARGET), \
 130   $(eval $(call DEFINE_LINKER,$(target))))
 131
 132 # The -Qunused-arguments sidesteps spurious warnings from clang
 133 define FILTER_FLAGS
 134   ifeq ($$(CFG_USING_CLANG),1)
 135     ifneq ($(findstring clang,$$(shell $(CC_$(1)) -v)),)
 136       CFG_GCCISH_CFLAGS_$(1) += -Qunused-arguments
 137       CFG_GCCISH_CXXFLAGS_$(1) += -Qunused-arguments
 138     endif
 139   endif
 140 endef
 141
 142 $(foreach target,$(CFG_TARGET), \
 143   $(eval $(call FILTER_FLAGS,$(target))))
 144
 145 # Configure various macros to pass gcc or cl.exe style arguments
 146 define CC_MACROS
 147   CFG_CC_INCLUDE_$(1)=-I $$(1)
 148   ifeq ($$(findstring msvc,$(1)),msvc)
 149     CFG_CC_OUTPUT_$(1)=-Fo:$$(1)
 150     CFG_CREATE_ARCHIVE_$(1)=$$(AR_$(1)) -OUT:$$(1)
 151   else
 152     CFG_CC_OUTPUT_$(1)=-o $$(1)
 153     CFG_CREATE_ARCHIVE_$(1)=$$(AR_$(1)) crus $$(1)
 154   endif
 155 endef
 156
 157 $(foreach target,$(CFG_TARGET), \
 158   $(eval $(call CC_MACROS,$(target))))
 159
 160
 161 ifeq ($(CFG_CCACHE_CPP2),1)
 162   CCACHE_CPP2=1
 163   export CCACHE_CPP
 164 endif
 165
 166 ifdef CFG_CCACHE_BASEDIR
 167   CCACHE_BASEDIR=$(CFG_CCACHE_BASEDIR)
 168   export CCACHE_BASEDIR
 169 endif
 170
 171 FIND_COMPILER = $(word 1,$(1:ccache=))
 172
 173 define CFG_MAKE_TOOLCHAIN
 174   # Prepend the tools with their prefix if cross compiling
 175   ifneq ($(CFG_BUILD),$(1))
 176     ifneq ($$(findstring msvc,$(1)),msvc)
 177        CC_$(1)=$(CROSS_PREFIX_$(1))$(CC_$(1))
 178        CXX_$(1)=$(CROSS_PREFIX_$(1))$(CXX_$(1))
 179        CPP_$(1)=$(CROSS_PREFIX_$(1))$(CPP_$(1))
 180        AR_$(1)=$(CROSS_PREFIX_$(1))$(AR_$(1))
 181        LINK_$(1)=$(CROSS_PREFIX_$(1))$(LINK_$(1))
 182        RUSTC_CROSS_FLAGS_$(1)=-C linker=$$(call FIND_COMPILER,$$(LINK_$(1))) \
 183            -C ar=$$(call FIND_COMPILER,$$(AR_$(1))) $(RUSTC_CROSS_FLAGS_$(1))
 184
 185        RUSTC_FLAGS_$(1)=$$(RUSTC_CROSS_FLAGS_$(1)) $(RUSTC_FLAGS_$(1))
 186     endif
 187   endif
 188
 189   CFG_COMPILE_C_$(1) = $$(CC_$(1)) \
 190         $$(CFG_GCCISH_CFLAGS) \
 191         $$(CFG_GCCISH_CFLAGS_$(1)) \
 192         -c $$(call CFG_CC_OUTPUT_$(1),$$(1)) $$(2)
 193   CFG_LINK_C_$(1) = $$(CC_$(1)) \
 194         $$(CFG_GCCISH_LINK_FLAGS) -o $$(1) \
 195         $$(CFG_GCCISH_LINK_FLAGS_$(1)) \
 196         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
 197         $$(call CFG_INSTALL_NAME_$(1),$$(4))
 198   CFG_COMPILE_CXX_$(1) = $$(CXX_$(1)) \
 199         $$(CFG_GCCISH_CFLAGS) \
 200         $$(CFG_GCCISH_CXXFLAGS) \
 201         $$(CFG_GCCISH_CFLAGS_$(1)) \
 202         $$(CFG_GCCISH_CXXFLAGS_$(1)) \
 203         -c $$(call CFG_CC_OUTPUT_$(1),$$(1)) $$(2)
 204   CFG_LINK_CXX_$(1) = $$(CXX_$(1)) \
 205         $$(CFG_GCCISH_LINK_FLAGS) -o $$(1) \
 206         $$(CFG_GCCISH_LINK_FLAGS_$(1)) \
 207         $$(CFG_GCCISH_DEF_FLAG_$(1))$$(3) $$(2) \
 208         $$(call CFG_INSTALL_NAME_$(1),$$(4))
 209
 210   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 211
 212   # On Bitrig, we need the relocation model to be PIC for everything
 213   ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
 214     LLVM_MC_RELOCATION_MODEL="pic"
 215   else
 216     LLVM_MC_RELOCATION_MODEL="default"
 217   endif
 218
 219   # We're using llvm-mc as our assembler because it supports
 220   # .cfi pseudo-ops on mac
 221   CFG_ASSEMBLE_$(1)=$$(CPP_$(1)) -E $$(2) | \
 222                     $$(LLVM_MC_$$(CFG_BUILD)) \
 223                     -assemble \
 224                     -relocation-model=$$(LLVM_MC_RELOCATION_MODEL) \
 225                     -filetype=obj \
 226                     -triple=$(1) \
 227                     -o=$$(1)
 228   else
 229
 230   # For the ARM, AARCH64, MIPS and POWER crosses, use the toolchain assembler
 231   # FIXME: We should be able to use the LLVM assembler
 232   CFG_ASSEMBLE_$(1)=$$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
 233                    $$(2) -c -o $$(1)
 234
 235   endif
 236
 237 endef
 238
 239 $(foreach target,$(CFG_TARGET), \
 240   $(eval $(call CFG_MAKE_TOOLCHAIN,$(target))))
 241
 242 # There are more comments about this available in the target specification for
 243 # Windows MSVC in the compiler, but the gist of it is that we use `llvm-ar.exe`
 244 # instead of `lib.exe` for assembling archives, so we need to inject this custom
 245 # dependency here.
 246 define ADD_LLVM_AR_TO_MSVC_DEPS
 247 ifeq ($$(findstring msvc,$(1)),msvc)
 248 NATIVE_TOOL_DEPS_core_T_$(1) += llvm-ar.exe
 249 INSTALLED_BINS_$(1) += llvm-ar.exe
 250 endif
 251 endef
 252
 253 $(foreach target,$(CFG_TARGET), \
 254   $(eval $(call ADD_LLVM_AR_TO_MSVC_DEPS,$(target))))
 255
 256 # When working with MSVC on windows, each DLL needs to explicitly declare its
 257 # interface to the outside world through some means. The options for doing so
 258 # include:
 259 #
 260 # 1. A custom attribute on each function itself
 261 # 2. A linker argument saying what to export
 262 # 3. A file which lists all symbols that need to be exported
 263 #
 264 # The Rust compiler takes care (1) for us for all Rust code by annotating all
 265 # public-facing functions with dllexport, but we have a few native dependencies
 266 # which need to cross the DLL boundary. The most important of these dependencies
 267 # is LLVM which is linked into `rustc_llvm.dll` but primarily used from
 268 # `rustc_trans.dll`. This means that many of LLVM's C API functions need to be
 269 # exposed from `rustc_llvm.dll` to be forwarded over the boundary.
 270 #
 271 # Unfortunately, at this time, LLVM does not handle this sort of exportation on
 272 # Windows for us, so we're forced to do it ourselves if we want it (which seems
 273 # like the path of least resistance right now). To do this we generate a `.DEF`
 274 # file [1] which we then custom-pass to the linker when building the rustc_llvm
 275 # crate. This DEF file list all symbols that are exported from
 276 # `src/librustc_llvm/lib.rs` and is generated by a small python script.
 277 #
 278 # Fun times!
 279 #
 280 # [1]: https://msdn.microsoft.com/en-us/library/28d6s79h.aspx
 281 define ADD_RUSTC_LLVM_DEF_TO_MSVC
 282 ifeq ($$(findstring msvc,$(1)),msvc)
 283 RUSTFLAGS_rustc_llvm_T_$(1) += -C link-args="-DEF:$(1)/rt/rustc_llvm.def"
 284 CUSTOM_DEPS_rustc_llvm_T_$(1) += $(1)/rt/rustc_llvm.def
 285
 286 $(1)/rt/rustc_llvm.def: $$(S)src/etc/mklldef.py $$(S)src/librustc_llvm/lib.rs
 287         $$(CFG_PYTHON) $$^ $$@ rustc_llvm-$$(CFG_FILENAME_EXTRA)
 288 endif
 289 endef
 290
 291 $(foreach target,$(CFG_TARGET), \
 292   $(eval $(call ADD_RUSTC_LLVM_DEF_TO_MSVC,$(target))))
 293