basic builds function

Author: nikomatsakis

Makefile.in

@@ -42,6 +42,8 @@
 #
 # Admittedly this is a little convoluted.
 
+STAGES = 0 1 2 3
+
 ######################################################################
 # Residual auto-configuration
 ######################################################################
@@ -243,51 +245,52 @@ export CFG_PREFIX
 ######################################################################
 
 define SREQ
+# $(1) is the stage number
+# $(2) is the target triple
+# $(3) is the build triple
 
 # Destinations of artifacts for the host compiler
-HOST_ROOT$(1) = stage$(1)
-HOST_BIN$(1) = $$(HOST_ROOT$(1))/bin
-HOST_LIB$(1) = $$(HOST_ROOT$(1))/lib
+HROOT$(1)_H_$(3) = $(3)/stage$(1)
+HBIN$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/bin
+HLIB$(1)_H_$(3) = $$(HROOT$(1)_H_$(3))/lib
 
 # Destinations of artifacts for target architectures
-TARGET_ROOT$(1)$(2) = $$(HOST_LIB$(1))/rustc/$(2)
-TARGET_BIN$(1)$(2) = $$(TARGET_ROOT$(1)$(2))/bin
-TARGET_LIB$(1)$(2) = $$(TARGET_ROOT$(1)$(2))/lib
-
-# The target locations of artifacts for the host architecture (used for
-# promoting target binaries to host binaries)
-TARGET_HOST_ROOT$(1) = $$(TARGET_ROOT$(1)$$(CFG_HOST_TRIPLE))
-TARGET_HOST_BIN$(1) = $$(TARGET_BIN$(1)$$(CFG_HOST_TRIPLE))
-TARGET_HOST_LIB$(1) = $$(TARGET_LIB$(1)$$(CFG_HOST_TRIPLE))
+TROOT$(1)_T_$(2)_H_$(3) = $$(HLIB$(1)_H_$(3))/rustc/$(2)
+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
 
 # The name of the standard library used by rustc
 ifdef CFG_DISABLE_SHAREDSTD
-  HOST_STDLIB_DEFAULT$(1) = $$(HOST_LIB$(1))/libstd.rlib
-  TARGET_STDLIB_DEFAULT$(1)$(2) = $$(TARGET_LIB$(1)$(2))/libstd.rlib
+  HSTDLIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/libstd.rlib
+  TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/libstd.rlib
 else
-  HOST_STDLIB_DEFAULT$(1) = $$(HOST_LIB$(1))/$(CFG_STDLIB)
-  TARGET_STDLIB_DEFAULT$(1)$(2) = $$(TARGET_LIB$(1)$(2))/$(CFG_STDLIB)
+  HSTDLIB_DEFAULT$(1)_H_$(3) = \
+    $$(HLIB$(1)_H_$(3))/$(CFG_STDLIB)
+  TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB)
 endif
 
 # Preqrequisites for using the stageN compiler
-HOST_SREQ$(1) = \
-	$$(HOST_BIN$(1))/rustc$$(X) \
-	$$(HOST_LIB$(1))/$$(CFG_RUNTIME) \
-	$$(HOST_LIB$(1))/$$(CFG_RUSTLLVM) \
-	$$(HOST_STDLIB_DEFAULT$(1)) \
+HSREQ$(1)_H_$(3) = \
+	$$(HBIN$(1)_H_$(3))/rustc$$(X) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_RUNTIME) \
+	$$(HLIB$(1)_H_$(3))/$$(CFG_RUSTLLVM) \
+	$$(HSTDLIB_DEFAULT$(1)_H_$(3)) \
 	$$(MKFILES)
 
 # Prerequisites for using the stageN compiler to build target artifacts
-TARGET_SREQ$(1)$(2) = \
-	$$(HOST_SREQ$(1)) \
-	$$(TARGET_LIB$(1)$(2))/$$(CFG_RUNTIME) \
-	$$(TARGET_LIB$(1)$(2))/intrinsics.bc \
-	$$(TARGET_LIB$(1)$(2))/libmorestack.a
+TSREQ$(1)_T_$(2)_H_$(3) = \
+	$$(HSREQ$(1)_H_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUNTIME) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/intrinsics.bc \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a
 
 # Prerequisites for complete stageN targets
-SREQ$(1)$(2) = \
-	$$(TARGET_SREQ$(1)$(2)) \
-	$$(TARGET_LIB$(1)$(2))/$$(CFG_STDLIB)
+SREQ$(1)_T_$(2)_H_$(3) = \
+	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB)
 
 ifeq ($(1),0)
 # Don't run the the stage0 compiler under valgrind - that ship has sailed
@@ -296,21 +299,24 @@ else
 CFG_VALGRIND_COMPILE$(1) = $$(CFG_VALGRIND_COMPILE)
 endif
 
-STAGE$(1)_$(2) := $$(Q)$$(call CFG_RUN_TARG,$(1), \
-                  $$(CFG_VALGRIND_COMPILE$(1)) $$(HOST_BIN$(1))/rustc$$(X) \
-                  $$(CFG_RUSTC_FLAGS) --target=$(2))
+STAGE$(1)_T_$(2)_H_$(3) := 						\
+	$$(Q)$$(call CFG_RUN_TARG,$(1),				\
+		$$(CFG_VALGRIND_COMPILE$(1)) 			\
+		$$(HBIN$(1)_H_$(3))/rustc$$(X)			\
+		$$(CFG_RUSTC_FLAGS) --target=$(2))
 
-PERF_STAGE$(1)_$(2) := $$(Q)$$(call CFG_RUN_TARG,$(1), \
-                       $$(CFG_PERF_TOOL) $$(HOST_BIN$(1))/rustc$$(X) \
-                       $$(CFG_RUSTC_FLAGS) --target=$(2))
+PERF_STAGE$(1)_T_$(2)_H_$(3) := 				\
+	$$(Q)$$(call CFG_RUN_TARG,$(1),				\
+		$$(CFG_PERF_TOOL) 						\
+		$$(HBIN$(1)_H_$(3))/rustc$$(X)			\
+		$$(CFG_RUSTC_FLAGS) --target=$(2))
 
 endef
 
-$(foreach target,$(CFG_TARGET_TRIPLES), \
- $(eval $(call SREQ,0,$(target))) \
- $(eval $(call SREQ,1,$(target))) \
- $(eval $(call SREQ,2,$(target))) \
- $(eval $(call SREQ,3,$(target))))
+$(foreach build,$(CFG_TARGET_TRIPLES), \
+ $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
+  $(eval $(foreach stage,$(STAGES), \
+   $(eval $(call SREQ,$(stage),$(target),$(build))))))))
 
 ######################################################################
 # Entrypoint rule
@@ -327,11 +333,13 @@ all: $(SREQ1$(CFG_HOST_TRIPLE)) $(GENERATED) $(DOCS)
 
 else
 
-TARGET_SREQS := $(foreach target,$(CFG_TARGET_TRIPLES),$(SREQ3$(target)))
-FUZZ := $(HOST_BIN3)/fuzzer$(X)
+TSREQS :=											\
+	$(foreach target,$(CFG_TARGET_TRIPLES),			\
+		$(SREQ3_T_$(target)_H_$(CFG_HOST_TRIPLE)))
+FUZZ := $(HBIN3_H_$(CFG_HOST_TRIPLE))/fuzzer$(X)
 
 #all: $(SREQ3$(CFG_HOST_TRIPLE)) $(GENERATED) $(DOCS) $(FUZZ)
-all: $(TARGET_SREQS) $(GENERATED) $(DOCS) $(FUZZ)
+all: $(TSREQS) $(GENERATED) $(DOCS) $(FUZZ)
 
 endif
 

configure

@@ -380,25 +380,27 @@ do
   done
 done
 
-for t in $CFG_TARGET_TRIPLES
+for h in $CFG_TARGET_TRIPLES
 do
-    for i in 0 1 2 3
+    for t in $CFG_TARGET_TRIPLES
     do
-        # host bin dir
-        make_dir stage$i/bin
+        for i in 0 1 2 3
+        do
+            # host bin dir
+            make_dir $h/stage$i/bin
 
-        # host lib dir
-        make_dir stage$i/lib
+            # host lib dir
+            make_dir $h/stage$i/lib
 
-        # target bin dir
-        make_dir stage$i/lib/rustc/$t/bin
+            # target bin dir
+            make_dir $h/stage$i/lib/rustc/$t/bin
 
-        # target lib dir
-        make_dir stage$i/lib/rustc/$t/lib
+            # target lib dir
+            make_dir $h/stage$i/lib/rustc/$t/lib
+        done
     done
 done
 
-
 # Configure submodules
 step_msg "configuring submodules"
 

mk/clean.mk

@@ -2,12 +2,16 @@
 # Cleanup
 ######################################################################
 
-CLEAN_STAGE_RULES = $(foreach target,$(CFG_TARGET_TRIPLES), \
- clean0$(target) clean1$(target) clean2$(target) clean3$(target)) \
- clean0 clean1 clean2 clean3
+CLEAN_STAGE_RULES =								\
+ $(foreach stage, $(STAGES),					\
+  $(foreach host, $(CFG_TARGET_TRIPLES),		\
+   clean$(stage)_H_$(host)						\
+   $(foreach target, $(CFG_TARGET_TRIPLES),		\
+    clean$(stage)_H_$(host)_T_$(target))))
 
-CLEAN_LLVM_RULES = $(foreach target,$(CFG_TARGET_TRIPLES), \
-                   clean-llvm$(target))
+CLEAN_LLVM_RULES = 								\
+ $(foreach target, $(CFG_TARGET_TRIPLES),		\
+  clean-llvm$(target))
 
 .PHONY: clean clean-all clean-misc
 
@@ -45,41 +49,45 @@ clean-misc:
 	$(Q)rm -Rf doc/version.texi
 	$(Q)rm -rf libuv
 
-define CLEAN_STAGE_N
-
-clean$(1):
-	$(Q)rm -f $$(HOST_BIN$(1))/rustc$(X)
-	$(Q)rm -f $$(HOST_BIN$(1))/fuzzer$(X)
-	$(Q)rm -f $$(HOST_LIB$(1))/$(CFG_RUNTIME)
-	$(Q)rm -f $$(HOST_LIB$(1))/$(CFG_STDLIB)
-	$(Q)rm -f $$(HOST_LIB$(1))/$(CFG_RUSTLLVM)
-	$(Q)rm -f $$(HOST_LIB$(1))/libstd.rlib
-
-clean$(1)$(2):
-	$(Q)rm -f $$(TARGET_BIN$(1)$(2))/rustc$(X)
-	$(Q)rm -f $$(TARGET_BIN$(1)$(2))/fuzzer$(X)
-	$(Q)rm -f $$(TARGET_LIB$(1)$(2))/$(CFG_RUNTIME)
-	$(Q)rm -f $$(TARGET_LIB$(1)$(2))/$(CFG_STDLIB)
-	$(Q)rm -f $$(TARGET_LIB$(1)$(2))/$(CFG_RUSTLLVM)
-	$(Q)rm -f $$(TARGET_LIB$(1)$(2))/libstd.rlib
-	$(Q)rm -f $$(TARGET_LIB$(1)$(2))/intrinsics.bc
+define CLEAN_HOST_STAGE_N
+
+clean$(1)_H_$(2):
+	$(Q)rm -f $$(HBIN$(1)_H_$(2))/rustc$(X)
+	$(Q)rm -f $$(HBIN$(1)_H_$(2))/fuzzer$(X)
+	$(Q)rm -f $$(HLIB$(1)_H_$(2))/$(CFG_RUNTIME)
+	$(Q)rm -f $$(HLIB$(1)_H_$(2))/$(CFG_STDLIB)
+	$(Q)rm -f $$(HLIB$(1)_H_$(2))/$(CFG_RUSTLLVM)
+	$(Q)rm -f $$(HLIB$(1)_H_$(2))/libstd.rlib
 
 endef
 
-$(foreach target, $(CFG_TARGET_TRIPLES), \
- $(eval $(call CLEAN_STAGE_N,0,$(target))) \
- $(eval $(call CLEAN_STAGE_N,1,$(target))) \
- $(eval $(call CLEAN_STAGE_N,2,$(target))) \
- $(eval $(call CLEAN_STAGE_N,3,$(target))))
+$(foreach host, $(CFG_TARGET_TRIPLES), \
+ $(eval $(foreach stage, $(STAGES), \
+  $(eval $(call CLEAN_HOST_STAGE_N,$(stage),$(host))))))
+
+define CLEAN_TARGET_STAGE_N
+
+clean$(1)_T_$(2)_H$(3):
+	$(Q)rm -f $$(TBIN$(1)_T_$(2)_H_$(3))/rustc$(X)
+	$(Q)rm -f $$(TBIN$(1)_T_$(2)_H_$(3))/fuzzer$(X)
+	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUNTIME)
+	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB)
+	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUSTLLVM)
+	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/libstd.rlib
+	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/intrinsics.bc
 
+endef
+
+$(foreach host, $(CFG_TARGET_TRIPLES), \
+ $(eval $(foreach target, $(CFG_TARGET_TRIPLES), \
+  $(eval $(foreach stage, $(STAGES), \
+   $(eval $(call CLEAN_TARGET_STAGE_N,$(stage),$(target),$(host))))))))
 
 define DEF_CLEAN_LLVM_TARGET
 ifeq ($(CFG_LLVM_ROOT),)
-
 clean-llvm$(1):
 	$$(Q)$$(MAKE) -C $$(CFG_LLVM_BUILD_DIR_$(1)) clean
 else
-
 clean-llvm$(1): ;
 
 endif

mk/host.mk

@@ -1,56 +1,59 @@
-# HOST_STAGE_N template: arg 1 is the N we're promoting *from*, arg 2
-# is N+1. Must be invoked to promote target artifacts to host artifacts
-# for stage 1-3 (stage0 host artifacts come from the snapshot).
+# CP_HOST_STAGE_N template: arg 1 is the N we're promoting *from*, arg
+# 2 is N+1. Must be invoked to promote target artifacts to host
+# artifacts for stage 1-3 (stage0 host artifacts come from the
+# snapshot).  Arg 3 is the triple we're copying FROM and arg 4 is the
+# triple we're copying TO.
 #
 # The easiest way to read this template is to assume we're promoting
 # stage1 to stage2 and mentally gloss $(1) as 1, $(2) as 2.
 
-define HOST_STAGE_N
+define CP_HOST_STAGE_N
 
 # Host libraries and executables (stage$(2)/bin/rustc and its runtime needs)
 
-$$(HOST_BIN$(2))/rustc$$(X): \
-	$$(TARGET_HOST_BIN$(1))/rustc$$(X) \
-	$$(HOST_LIB$(2))/$$(CFG_RUNTIME) \
-	$$(HOST_LIB$(2))/$$(CFG_RUSTLLVM) \
-	$$(HOST_STDLIB_DEFAULT$(2))
+$$(HBIN$(2)_H_$(4))/rustc$$(X): \
+	$$(TBIN$(1)_T_$(4)_H_$(3))/rustc$$(X) \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUNTIME) \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUSTLLVM) \
+	$$(HSTDLIB_DEFAULT$(2)_H_$(4))
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
 # FIXME: The fuzzer depends on this. Remove once it's rpathed to correctly
 # find it in the appropriate target directory
-$$(HOST_LIB$(2))/$$(CFG_LIBRUSTC): \
-	$$(TARGET_HOST_LIB$(1))/$$(CFG_LIBRUSTC) \
-	$$(HOST_LIB$(2))/$$(CFG_RUNTIME) \
-	$$(HOST_LIB$(2))/$$(CFG_RUSTLLVM) \
-	$$(HOST_STDLIB_DEFAULT$(2))
+$$(HLIB$(2)_H_$(4))/$$(CFG_LIBRUSTC): \
+	$$(TLIB$(1)_T_$(4)_H_$(3))/$$(CFG_LIBRUSTC) \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUNTIME) \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUSTLLVM) \
+	$$(HSTDLIB_DEFAULT$(2)_H_$(3))
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
-$$(HOST_LIB$(2))/$$(CFG_RUNTIME): \
-	$$(TARGET_HOST_LIB$(1))/$$(CFG_RUNTIME)
+$$(HLIB$(2)_H_$(4))/$$(CFG_RUNTIME): \
+	$$(TLIB$(1)_T_$(4)_H_$(3))/$$(CFG_RUNTIME)
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
-$$(HOST_LIB$(2))/$$(CFG_STDLIB): \
-	$$(TARGET_HOST_LIB$(1))/$$(CFG_STDLIB) \
-	$$(HOST_LIB$(2))/$$(CFG_RUNTIME)
+$$(HLIB$(2)_H_$(4))/$$(CFG_STDLIB): \
+	$$(TLIB$(1)_T_$(4)_H_$(3))/$$(CFG_STDLIB) \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUNTIME)
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
-$$(HOST_LIB$(2))/libstd.rlib: \
-	$$(TARGET_HOST_LIB$(1))/libstd.rlib \
-	$$(HOST_LIB$(2))/$$(CFG_RUNTIME)
+$$(HLIB$(2)_H_$(4))/libstd.rlib: \
+	$$(TLIB$(1)_T_$(4)_H_$(3))/libstd.rlib \
+	$$(HLIB$(2)_H_$(4))/$$(CFG_RUNTIME)
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
-$$(HOST_LIB$(2))/$$(CFG_RUSTLLVM): \
-	$$(TARGET_HOST_LIB$(1))/$$(CFG_RUSTLLVM)
+$$(HLIB$(2)_H_$(4))/$$(CFG_RUSTLLVM): \
+	$$(TLIB$(1)_T_$(4)_H_$(3))/$$(CFG_RUSTLLVM)
 	@$$(call E, cp: $$@)
 	$$(Q)cp $$< $$@
 
 endef
 
-$(eval $(call HOST_STAGE_N,0,1))
-$(eval $(call HOST_STAGE_N,1,2))
-$(eval $(call HOST_STAGE_N,2,3))
+$(foreach t,$(CFG_TARGET_TRIPLES),					\
+	$(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))))