[rustc.git] / mk / dist.mk

# 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)

# 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                             \
      compiletest                              \
      doc                                      \
      driver                                   \
      etc                                      \
      $(foreach crate,$(CRATES),lib$(crate))   \
      libcollectionstest                       \
      libcoretest                              \
      libbacktrace                             \
      rt                                       \
      rtstartup                                \
      rustllvm                                 \
      rustc                                    \
      snapshots.txt                            \
      rust-installer                           \
      tools                                    \
      test)                                    \
    $(PKG_GITMODULES)                          \
    $(filter-out config.stamp, \
                 $(MKFILES_FOR_TARBALL))

UNROOTED_PKG_FILES := $(patsubst $(S)%,./%,$(PKG_FILES))

$(PKG_TAR): $(PKG_FILES)
	@$(call E, making dist dir)
	$(Q)rm -Rf tmp/dist/$(PKG_NAME)
	$(Q)mkdir -p tmp/dist/$(PKG_NAME)
	$(Q)tar \
         -C $(S) \
         --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 -C tmp/dist/$(PKG_NAME)
	@$(call E, making $@)
	$(Q)tar -czf $(PKG_TAR) -C tmp/dist $(PKG_NAME)
	$(Q)rm -Rf tmp/dist/$(PKG_NAME)

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))))

# 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
MAYBE_DISTCHECK_TAR_SRC=distcheck-tar-src

# 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
Commit	Line	Data
1a4d82fc JJ	1	# Copyright 2014 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
223e47cc LB	11	######################################################################
	12	# Distribution
	13	######################################################################
	14
1a4d82fc JJ	15	# Primary targets:
	16	#
	17	# * dist - make all distribution artifacts
	18	# * distcheck - sanity check dist artifacts
	19	# * dist-tar-src - source tarballs
	20	# * dist-tar-bins - Ad-hoc Unix binary installers
	21	# * dist-docs - Stage docs for upload
223e47cc	22
1a4d82fc	23	PKG_NAME := $(CFG_PACKAGE_NAME)
b039eaaf	24	STD_PKG_NAME := rust-std-$(CFG_PACKAGE_VERS)
1a4d82fc JJ	25	DOC_PKG_NAME := rust-docs-$(CFG_PACKAGE_VERS)
	26	MINGW_PKG_NAME := rust-mingw-$(CFG_PACKAGE_VERS)
	27
	28	# License suitable for displaying in a popup
	29	LICENSE.txt: $(S)COPYRIGHT $(S)LICENSE-APACHE $(S)LICENSE-MIT
	30	cat $^ > $@
	31
	32
	33	######################################################################
	34	# Source tarball
	35	######################################################################
223e47cc	36
1a4d82fc	37	PKG_TAR = dist/$(PKG_NAME)-src.tar.gz
223e47cc	38
1a4d82fc JJ	39	PKG_GITMODULES := $(S)src/llvm $(S)src/compiler-rt \
1a4d82fc JJ	40	$(S)src/rt/hoedown $(S)src/jemalloc
223e47cc LB	41	PKG_FILES := \
	42	$(S)COPYRIGHT \
	43	$(S)LICENSE-APACHE \
	44	$(S)LICENSE-MIT \
1a4d82fc	45	$(S)CONTRIBUTING.md \
223e47cc	46	$(S)README.md \
1a4d82fc	47	$(S)RELEASES.md \
223e47cc LB	48	$(S)configure $(S)Makefile.in \
223e47cc LB	49	$(S)man \
223e47cc	50	$(addprefix $(S)src/, \
7453a54e SL	51	bootstrap \
7453a54e SL	52	build_helper \
223e47cc	53	compiletest \
1a4d82fc JJ	54	doc \
1a4d82fc JJ	55	driver \
223e47cc	56	etc \
1a4d82fc	57	$(foreach crate,$(CRATES),lib$(crate)) \
c34b1796	58	libcollectionstest \
1a4d82fc JJ	59	libcoretest \
1a4d82fc JJ	60	libbacktrace \
223e47cc	61	rt \
92a42be0	62	rtstartup \
223e47cc	63	rustllvm \
7453a54e	64	rustc \
223e47cc	65	snapshots.txt \
1a4d82fc	66	rust-installer \
54a0048b	67	tools \
223e47cc LB	68	test) \
223e47cc LB	69	$(PKG_GITMODULES) \
1a4d82fc JJ	70	$(filter-out config.stamp, \
1a4d82fc JJ	71	$(MKFILES_FOR_TARBALL))
223e47cc LB	72
	73	UNROOTED_PKG_FILES := $(patsubst $(S)%,./%,$(PKG_FILES))
	74
223e47cc LB	75	$(PKG_TAR): $(PKG_FILES)
223e47cc LB	76	@$(call E, making dist dir)
1a4d82fc JJ	77	$(Q)rm -Rf tmp/dist/$(PKG_NAME)
1a4d82fc JJ	78	$(Q)mkdir -p tmp/dist/$(PKG_NAME)
223e47cc LB	79	$(Q)tar \
	80	-C $(S) \
	81	--exclude-vcs \
	82	--exclude=*~ \
b039eaaf	83	--exclude=*.pyc \
223e47cc LB	84	--exclude=/llvm/test//*.ll \
	85	--exclude=/llvm/test//*.td \
	86	--exclude=/llvm/test//*.s \
	87	--exclude=/llvm/test///.ll \
	88	--exclude=/llvm/test///.td \
	89	--exclude=/llvm/test///.s \
1a4d82fc JJ	90	-c $(UNROOTED_PKG_FILES) \| tar -x -C tmp/dist/$(PKG_NAME)
	91	@$(call E, making $@)
	92	$(Q)tar -czf $(PKG_TAR) -C tmp/dist $(PKG_NAME)
	93	$(Q)rm -Rf tmp/dist/$(PKG_NAME)
223e47cc	94
1a4d82fc	95	dist-tar-src: $(PKG_TAR)
223e47cc	96
1a4d82fc JJ	97	distcheck-tar-src: dist-tar-src
	98	$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)
	99	$(Q)rm -Rf tmp/distcheck/srccheck
	100	$(Q)mkdir -p tmp/distcheck
	101	@$(call E, unpacking $(PKG_TAR) in tmp/distcheck/$(PKG_NAME))
	102	$(Q)cd tmp/distcheck && tar -xzf ../../$(PKG_TAR)
	103	@$(call E, configuring in tmp/distcheck/srccheck)
	104	$(Q)mkdir -p tmp/distcheck/srccheck
	105	$(Q)cd tmp/distcheck/srccheck && ../$(PKG_NAME)/configure
	106	@$(call E, making 'check' in tmp/distcheck/srccheck)
	107	$(Q)+make -C tmp/distcheck/srccheck check
	108	@$(call E, making 'clean' in tmp/distcheck/srccheck)
	109	$(Q)+make -C tmp/distcheck/srccheck clean
	110	$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)
	111	$(Q)rm -Rf tmp/distcheck/srccheck
223e47cc	112
223e47cc	113
1a4d82fc JJ	114	######################################################################
	115	# Unix binary installer tarballs
	116	######################################################################
	117
b039eaaf SL	118	define DEF_START_INSTALLER
	119	dist-install-dir-$(1)-%: PREPARE_DIR_CMD=$(DEFAULT_PREPARE_DIR_CMD)
	120	dist-install-dir-$(1)-%: PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
	121	dist-install-dir-$(1)-%: PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
	122	dist-install-dir-$(1)-%: PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
	123	dist-install-dir-$(1)-%: PREPARE_CLEAN=true
1a4d82fc JJ	124
1a4d82fc JJ	125	$$(eval $$(call DEF_PREPARE,dir-$(1)))
b039eaaf	126	endef
1a4d82fc	127
b039eaaf SL	128	$(foreach target,$(CFG_TARGET),\
	129	$(eval $(call DEF_START_INSTALLER,$(target))))
	130
	131	define DEF_INSTALLER
	132
	133	dist-install-dir-$(1)-host: PREPARE_HOST=$(1)
	134	dist-install-dir-$(1)-host: PREPARE_TARGETS=$(2)
	135	dist-install-dir-$(1)-host: PREPARE_DEST_DIR=tmp/dist/$$(PKG_NAME)-$(1)-image
	136	dist-install-dir-$(1)-host: prepare-base-dir-$(1)-host docs
1a4d82fc JJ	137	$$(Q)mkdir -p $$(PREPARE_DEST_DIR)/share/doc/rust
	138	$$(Q)$$(PREPARE_MAN_CMD) $$(S)COPYRIGHT $$(PREPARE_DEST_DIR)/share/doc/rust
	139	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)/share/doc/rust
	140	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-MIT $$(PREPARE_DEST_DIR)/share/doc/rust
	141	$$(Q)$$(PREPARE_MAN_CMD) $$(S)README.md $$(PREPARE_DEST_DIR)/share/doc/rust
85aaf69f SL	142
	143	prepare-overlay-$(1):
	144	$$(Q)rm -Rf tmp/dist/$$(PKG_NAME)-$(1)-overlay
	145	$$(Q)mkdir -p tmp/dist/$$(PKG_NAME)-$(1)-overlay
	146	$$(Q)cp $$(S)COPYRIGHT tmp/dist/$$(PKG_NAME)-$(1)-overlay/
	147	$$(Q)cp $$(S)LICENSE-APACHE tmp/dist/$$(PKG_NAME)-$(1)-overlay/
	148	$$(Q)cp $$(S)LICENSE-MIT tmp/dist/$$(PKG_NAME)-$(1)-overlay/
	149	$$(Q)cp $$(S)README.md tmp/dist/$$(PKG_NAME)-$(1)-overlay/
1a4d82fc	150	# This tiny morsel of metadata is used by rust-packaging
85aaf69f	151	$$(Q)echo "$(CFG_VERSION)" > tmp/dist/$$(PKG_NAME)-$(1)-overlay/version
1a4d82fc	152
b039eaaf	153	dist/$$(PKG_NAME)-$(1).tar.gz: dist-install-dir-$(1)-host prepare-overlay-$(1)
1a4d82fc	154	@$(call E, build: $$@)
b039eaaf SL	155	# On a MinGW target we've got a few runtime DLL dependencies that we need
	156	# to include. THe first argument to `make-win-dist` is where to put these DLLs
	157	# (the image we're creating) and the second argument is a junk directory to
	158	# ignore all the other MinGW stuff the script creates.
	159	ifeq ($$(findstring pc-windows-gnu,$(1)),pc-windows-gnu)
1a4d82fc	160	$$(Q)rm -Rf tmp/dist/win-rust-gcc-$(1)
b039eaaf SL	161	$$(Q)$$(CFG_PYTHON) $$(S)src/etc/make-win-dist.py \
	162	tmp/dist/$$(PKG_NAME)-$(1)-image \
	163	tmp/dist/win-rust-gcc-$(1) $(1)
	164	endif
	165	# On 32-bit MinGW we're always including a DLL which needs some extra licenses
	166	# to distribute. On 64-bit MinGW we don't actually distribute anything requiring
	167	# us to distribute a license but it's likely that the install will also
	168	# include the rust-mingw package down below, which also need licenses, so to be
	169	# safe we just inlude it here in all MinGW packages.
	170	ifdef CFG_WINDOWSY_$(1)
	171	ifeq ($$(findstring $(1),gnu),gnu)
	172	$$(Q)cp -r $$(S)src/etc/third-party \
	173	tmp/dist/$$(PKG_NAME)-$(1)-image/share/doc/
62682a34	174	endif
1a4d82fc JJ	175	endif
	176	$$(Q)$$(S)src/rust-installer/gen-installer.sh \
	177	--product-name=Rust \
1a4d82fc JJ	178	--rel-manifest-dir=rustlib \
	179	--success-message=Rust-is-ready-to-roll. \
	180	--image-dir=tmp/dist/$$(PKG_NAME)-$(1)-image \
	181	--work-dir=tmp/dist \
	182	--output-dir=dist \
85aaf69f	183	--non-installed-overlay=tmp/dist/$$(PKG_NAME)-$(1)-overlay \
1a4d82fc JJ	184	--package-name=$$(PKG_NAME)-$(1) \
	185	--component-name=rustc \
	186	--legacy-manifest-dirs=rustlib,cargo
	187	$$(Q)rm -R tmp/dist/$$(PKG_NAME)-$(1)-image
	188
62682a34	189	dist-doc-install-dir-$(1): docs
1a4d82fc JJ	190	$$(Q)mkdir -p tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust
1a4d82fc JJ	191	$$(Q)cp -r doc tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust/html
223e47cc	192
1a4d82fc JJ	193	dist/$$(DOC_PKG_NAME)-$(1).tar.gz: dist-doc-install-dir-$(1)
	194	@$(call E, build: $$@)
	195	$$(Q)$$(S)src/rust-installer/gen-installer.sh \
	196	--product-name=Rust-Documentation \
	197	--rel-manifest-dir=rustlib \
	198	--success-message=Rust-documentation-is-installed. \
	199	--image-dir=tmp/dist/$$(DOC_PKG_NAME)-$(1)-image \
	200	--work-dir=tmp/dist \
	201	--output-dir=dist \
	202	--package-name=$$(DOC_PKG_NAME)-$(1) \
	203	--component-name=rust-docs \
	204	--legacy-manifest-dirs=rustlib,cargo \
	205	--bulk-dirs=share/doc/rust/html
	206	$$(Q)rm -R tmp/dist/$$(DOC_PKG_NAME)-$(1)-image
	207
b039eaaf SL	208	# Creates the rust-mingw package, and the first argument to make-win-dist is a
	209	# "temporary directory" which is just thrown away (this contains the runtime
	210	# DLLs included in the rustc package above) and the second argument is where to
	211	# place all the MinGW components (which is what we want).
1a4d82fc JJ	212	dist-mingw-install-dir-$(1):
	213	$$(Q)mkdir -p tmp/dist/rust-mingw-tmp-$(1)-image
	214	$$(Q)rm -Rf tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image
	215	$$(Q)$$(CFG_PYTHON) $$(S)src/etc/make-win-dist.py \
b039eaaf SL	216	tmp/dist/rust-mingw-tmp-$(1)-image \
b039eaaf SL	217	tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image $(1)
1a4d82fc JJ	218
	219	dist/$$(MINGW_PKG_NAME)-$(1).tar.gz: dist-mingw-install-dir-$(1)
	220	@$(call E, build: $$@)
	221	$$(Q)$$(S)src/rust-installer/gen-installer.sh \
	222	--product-name=Rust-MinGW \
	223	--rel-manifest-dir=rustlib \
	224	--success-message=Rust-MinGW-is-installed. \
	225	--image-dir=tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image \
	226	--work-dir=tmp/dist \
	227	--output-dir=dist \
	228	--package-name=$$(MINGW_PKG_NAME)-$(1) \
	229	--component-name=rust-mingw \
	230	--legacy-manifest-dirs=rustlib,cargo
	231	$$(Q)rm -R tmp/dist/$$(MINGW_PKG_NAME)-$(1)-image
	232
	233	endef
	234
b039eaaf SL	235	# $(1) - host
	236	# $(2) - target
	237	define DEF_INSTALLER_TARGETS
	238
	239	dist-install-dir-$(2)-target: PREPARE_HOST=$(1)
	240	dist-install-dir-$(2)-target: PREPARE_TARGETS=$(2)
	241	dist-install-dir-$(2)-target: PREPARE_DEST_DIR=tmp/dist/$$(STD_PKG_NAME)-$(2)-image
	242	dist-install-dir-$(2)-target: prepare-base-dir-$(2)-target
	243
	244	dist/$$(STD_PKG_NAME)-$(2).tar.gz: dist-install-dir-$(2)-target
	245	@$$(call E, build: $$@)
	246	$$(Q)$$(S)src/rust-installer/gen-installer.sh \
	247	--product-name=Rust \
	248	--rel-manifest-dir=rustlib \
	249	--success-message=std-is-standing-at-the-ready. \
	250	--image-dir=tmp/dist/$$(STD_PKG_NAME)-$(2)-image \
	251	--work-dir=tmp/dist \
	252	--output-dir=dist \
	253	--package-name=$$(STD_PKG_NAME)-$(2) \
	254	--component-name=rust-std-$(2) \
	255	--legacy-manifest-dirs=rustlib,cargo
	256	$$(Q)rm -R tmp/dist/$$(STD_PKG_NAME)-$(2)-image
	257	endef
	258
1a4d82fc	259	$(foreach host,$(CFG_HOST),\
b039eaaf	260	$(eval $(call DEF_INSTALLER,$(host))))
1a4d82fc	261
b039eaaf SL	262	# When generating packages for the standard library, we've actually got a lot of
	263	# artifacts to choose from. Each of the CFG_HOST compilers will have a copy of
	264	# the standard library for each CFG_TARGET, but we only want to generate one
	265	# standard library package. As a result, for each entry in CFG_TARGET we need to
	266	# pick a CFG_HOST to get the standard library from.
	267	#
	268	# In theory it doesn't actually matter what host we choose as it should be the
	269	# case that all hosts produce the same set of libraries for a target (regardless
	270	# of the host itself). Currently there is a bug in the compiler, however, which
	271	# means this is not the case (see #29228 and #29235). To solve the first of
	272	# those bugs, we prefer to select a standard library from the host it was
	273	# generated from, allowing plugins to work in more situations.
	274	#
	275	# For all CFG_TARGET entries in CFG_HOST, however, we just pick CFG_BUILD as the
	276	# host we slurp up a standard library from.
	277	$(foreach host,$(CFG_HOST),\
	278	$(eval $(call DEF_INSTALLER_TARGETS,$(host),$(host))))
	279	$(foreach target,$(filter-out $(CFG_HOST),$(CFG_TARGET)),\
	280	$(eval $(call DEF_INSTALLER_TARGETS,$(CFG_BUILD),$(target))))
1a4d82fc JJ	281
1a4d82fc JJ	282	ifdef CFG_WINDOWSY_$(CFG_BUILD)
62682a34 SL	283	define BUILD_MINGW_TARBALL
	284	ifeq ($$(findstring gnu,$(1)),gnu)
	285	MAYBE_MINGW_TARBALLS += dist/$(MINGW_PKG_NAME)-$(1).tar.gz
	286	endif
	287	endef
	288
	289	$(foreach host,$(CFG_HOST),\
	290	$(eval $(call BUILD_MINGW_TARBALL,$(host))))
1a4d82fc JJ	291	endif
	292
	293	ifeq ($(CFG_DISABLE_DOCS),)
	294	MAYBE_DOC_TARBALLS=$(foreach host,$(CFG_HOST),dist/$(DOC_PKG_NAME)-$(host).tar.gz)
	295	endif
	296
b039eaaf SL	297	dist-tar-bins: \
	298	$(foreach host,$(CFG_HOST),dist/$(PKG_NAME)-$(host).tar.gz) \
	299	$(foreach target,$(CFG_TARGET),dist/$(STD_PKG_NAME)-$(target).tar.gz) \
1a4d82fc JJ	300	$(MAYBE_DOC_TARBALLS) $(MAYBE_MINGW_TARBALLS)
	301
	302	# Just try to run the compiler for the build host
	303	distcheck-tar-bins: dist-tar-bins
	304	@$(call E, checking binary tarball)
	305	$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
	306	$(Q)rm -Rf tmp/distcheck/tarbininstall
	307	$(Q)mkdir -p tmp/distcheck
	308	$(Q)cd tmp/distcheck && tar -xzf ../../dist/$(PKG_NAME)-$(CFG_BUILD).tar.gz
	309	$(Q)mkdir -p tmp/distcheck/tarbininstall
	310	$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall
	311	$(Q)sh tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)/install.sh --prefix=tmp/distcheck/tarbininstall --uninstall
	312	$(Q)rm -Rf tmp/distcheck/$(PKG_NAME)-$(CFG_BUILD)
	313	$(Q)rm -Rf tmp/distcheck/tarbininstall
	314
	315	######################################################################
	316	# Docs
	317	######################################################################
	318
	319	# Just copy the docs to a folder under dist with the appropriate name
	320	# for uploading to S3
62682a34	321	dist-docs: docs
1a4d82fc JJ	322	$(Q) rm -Rf dist/doc
	323	$(Q) mkdir -p dist/doc/
	324	$(Q) cp -r doc dist/doc/$(CFG_PACKAGE_VERS)
223e47cc	325
1a4d82fc JJ	326	distcheck-docs: dist-docs
	327
	328	######################################################################
	329	# Primary targets (dist, distcheck)
	330	######################################################################
	331
	332	MAYBE_DIST_TAR_SRC=dist-tar-src
	333	MAYBE_DISTCHECK_TAR_SRC=distcheck-tar-src
	334
	335	# FIXME #13224: On OS X don't produce tarballs simply because --exclude-vcs don't work.
	336	# This is a huge hack because I just don't have time to figure out another solution.
	337	ifeq ($(CFG_OSTYPE), apple-darwin)
	338	MAYBE_DIST_TAR_SRC=
	339	MAYBE_DISTCHECK_TAR_SRC=
	340	endif
	341
	342	# Don't bother with source tarballs on windows just because we historically haven't.
	343	ifeq ($(CFG_OSTYPE), pc-windows-gnu)
	344	MAYBE_DIST_TAR_SRC=
	345	MAYBE_DISTCHECK_TAR_SRC=
	346	endif
	347
	348	ifneq ($(CFG_DISABLE_DOCS),)
	349	MAYBE_DIST_DOCS=
	350	MAYBE_DISTCHECK_DOCS=
	351	else
	352	MAYBE_DIST_DOCS=dist-docs
	353	MAYBE_DISTCHECK_DOCS=distcheck-docs
	354	endif
	355
	356	dist: $(MAYBE_DIST_TAR_SRC) dist-tar-bins $(MAYBE_DIST_DOCS)
	357
	358	distcheck: $(MAYBE_DISTCHECK_TAR_SRC) distcheck-tar-bins $(MAYBE_DISTCHECK_DOCS)
	359	$(Q)rm -Rf tmp/distcheck
223e47cc LB	360	@echo
223e47cc LB	361	@echo -----------------------------------------------
1a4d82fc	362	@echo "Rust ready for distribution (see ./dist)"
223e47cc LB	363	@echo -----------------------------------------------
223e47cc LB	364
1a4d82fc	365	.PHONY: dist distcheck