---

yaml
---
r: 46574
b: refs/heads/auto
c: 26a5dc5
h: refs/heads/master
v: v3

Author: yichoi

[refs]

@@ -14,4 +14,4 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: ea36a0dee1630e24ba2889ca13550026b1af4f9d
+refs/heads/auto: 26a5dc593c1895b4dd9a024ef785cb3682cb064a

branches/auto/.gitmodules

@@ -3,4 +3,4 @@
 	url = git://github.com/brson/llvm.git
 [submodule "src/libuv"]
 	path = src/libuv
-	url = git://github.com/joyent/libuv.git
+	url = https://github.com/ILyoan/libuv.git

branches/auto/Makefile.in

@@ -70,16 +70,22 @@ include config.mk
 ALL_OBJ_FILES :=
 
 MKFILE_DEPS := config.stamp $(call rwildcard,$(CFG_SRC_DIR)mk/,*)
-NON_HOST_TRIPLES = $(filter-out $(CFG_HOST_TRIPLE),$(CFG_TARGET_TRIPLES))
+NON_BUILD_HOST_TRIPLES = $(filter-out $(CFG_BUILD_TRIPLE),$(CFG_HOST_TRIPLES))
+NON_BUILD_TARGET_TRIPLES = $(filter-out $(CFG_BUILD_TRIPLE),$(CFG_TARGET_TRIPLES))
 
 ifneq ($(MAKE_RESTARTS),)
 CFG_INFO := $(info cfg: make restarts: $(MAKE_RESTARTS))
 endif
 
-CFG_INFO := $(info cfg: shell host triple $(CFG_HOST_TRIPLE))
+CFG_INFO := $(info cfg: build triple $(CFG_BUILD_TRIPLE))
+CFG_INFO := $(info cfg: host triples $(CFG_HOST_TRIPLES))
+CFG_INFO := $(info cfg: target triples $(CFG_TARGET_TRIPLES))
 
-ifneq ($(wildcard $(NON_HOST_TRIPLES)),)
-CFG_INFO := $(info cfg: non host triples $(NON_HOST_TRIPLES))
+ifneq ($(wildcard $(NON_BUILD_HOST_TRIPLES)),)
+CFG_INFO := $(info cfg: non-build host triples $(NON_BUILD_HOST_TRIPLES))
+endif
+ifneq ($(wildcard $(NON_BUILD_TARGET_TRIPLES)),)
+CFG_INFO := $(info cfg: non-build target triples $(NON_BUILD_TARGET_TRIPLES))
 endif
 
 CFG_RUSTC_FLAGS := $(RUSTFLAGS)
@@ -124,36 +130,43 @@ else
   CFG_VALGRIND_COMPILE :=
 endif
 
-CFG_RUNTIME :=$(call CFG_LIB_NAME,rustrt)
-CFG_RUSTLLVM :=$(call CFG_LIB_NAME,rustllvm)
-CFG_CORELIB :=$(call CFG_LIB_NAME,core)
-CFG_STDLIB :=$(call CFG_LIB_NAME,std)
-CFG_LIBRUSTC :=$(call CFG_LIB_NAME,rustc)
-CFG_LIBSYNTAX :=$(call CFG_LIB_NAME,syntax)
-CFG_LIBFUZZER :=$(call CFG_LIB_NAME,fuzzer)
-CFG_LIBRUSTPKG :=$(call CFG_LIB_NAME,rustpkg)
-CFG_LIBRUSTDOC :=$(call CFG_LIB_NAME,rustdoc)
-CFG_LIBRUSTI :=$(call CFG_LIB_NAME,rusti)
-CFG_LIBRUST :=$(call CFG_LIB_NAME,rust)
-
-STDLIB_GLOB :=$(call CFG_LIB_GLOB,std)
-CORELIB_GLOB :=$(call CFG_LIB_GLOB,core)
-LIBRUSTC_GLOB :=$(call CFG_LIB_GLOB,rustc)
-LIBSYNTAX_GLOB :=$(call CFG_LIB_GLOB,syntax)
-LIBFUZZER_GLOB :=$(call CFG_LIB_GLOB,fuzzer)
-LIBRUSTPKG_GLOB :=$(call CFG_LIB_GLOB,rustpkg)
-LIBRUSTDOC_GLOB :=$(call CFG_LIB_GLOB,rustdoc)
-LIBRUSTI_GLOB :=$(call CFG_LIB_GLOB,rusti)
-LIBRUST_GLOB :=$(call CFG_LIB_GLOB,rust)
-STDLIB_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,std)
-CORELIB_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,core)
-LIBRUSTC_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,rustc)
-LIBSYNTAX_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,syntax)
-LIBFUZZER_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,fuzzer)
-LIBRUSTPKG_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,rustpkg)
-LIBRUSTDOC_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,rustdoc)
-LIBRUSTI_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,rusti)
-LIBRUST_DSYM_GLOB :=$(call CFG_LIB_DSYM_GLOB,rust)
+define LIBREQ
+
+CFG_RUNTIME_$(1) :=$(call CFG_LIB_NAME_$(1),rustrt)
+CFG_RUSTLLVM_$(1) :=$(call CFG_LIB_NAME_$(1),rustllvm)
+CFG_CORELIB_$(1) :=$(call CFG_LIB_NAME_$(1),core)
+CFG_STDLIB_$(1) :=$(call CFG_LIB_NAME_$(1),std)
+CFG_LIBRUSTC_$(1) :=$(call CFG_LIB_NAME_$(1),rustc)
+CFG_LIBSYNTAX_$(1) :=$(call CFG_LIB_NAME_$(1),syntax)
+CFG_LIBFUZZER_$(1) :=$(call CFG_LIB_NAME_$(1),fuzzer)
+CFG_LIBRUSTPKG_$(1) :=$(call CFG_LIB_NAME_$(1),rustpkg)
+CFG_LIBRUSTDOC_$(1) :=$(call CFG_LIB_NAME_$(1),rustdoc)
+CFG_LIBRUSTI_$(1) :=$(call CFG_LIB_NAME_$(1),rusti)
+CFG_LIBRUST_$(1) :=$(call CFG_LIB_NAME_$(1),rust)
+
+STDLIB_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),std)
+CORELIB_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),core)
+LIBRUSTC_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),rustc)
+LIBSYNTAX_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),syntax)
+LIBFUZZER_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),fuzzer)
+LIBRUSTPKG_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),rustpkg)
+LIBRUSTDOC_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),rustdoc)
+LIBRUSTI_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),rusti)
+LIBRUST_GLOB_$(1) :=$(call CFG_LIB_GLOB_$(1),rust)
+STDLIB_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),std)
+CORELIB_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),core)
+LIBRUSTC_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustc)
+LIBSYNTAX_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),syntax)
+LIBFUZZER_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),fuzzer)
+LIBRUSTPKG_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustpkg)
+LIBRUSTDOC_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rustdoc)
+LIBRUSTI_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rusti)
+LIBRUST_DSYM_GLOB_$(1) :=$(call CFG_LIB_DSYM_GLOB_$(1),rust)
+
+endef
+
+$(foreach target,$(CFG_TARGET_TRIPLES), \
+  $(eval $(call LIBREQ,$(target))))
 
 # version-string calculation
 CFG_GIT_DIR := $(CFG_SRC_DIR).git
@@ -184,13 +197,13 @@ endif
 # Target-and-rule "utility variables"
 ######################################################################
 
-ifdef VERBOSE
+#ifdef VERBOSE
   Q :=
   E =
-else
-  Q := @
-  E = echo $(1)
-endif
+#else
+#  Q := @
+#  E = echo $(1)
+#endif
 
 S := $(CFG_SRC_DIR)
 X := $(CFG_EXE_SUFFIX)
@@ -272,8 +285,8 @@ LLC_$(1)=$$(CFG_LLVM_INST_DIR_$(1))/bin/llc$$(X)
 
 endef
 
-$(foreach target,$(CFG_TARGET_TRIPLES), \
- $(eval $(call DEF_LLVM_VARS,$(target))))
+$(foreach host,$(CFG_HOST_TRIPLES), \
+ $(eval $(call DEF_LLVM_VARS,$(host))))
 
 ######################################################################
 # Exports for sub-utilities
@@ -285,7 +298,7 @@ $(foreach target,$(CFG_TARGET_TRIPLES), \
 export CFG_SRC_DIR
 export CFG_BUILD_DIR
 export CFG_VERSION
-export CFG_HOST_TRIPLE
+export CFG_BUILD_TRIPLE
 export CFG_LLVM_ROOT
 export CFG_ENABLE_MINGW_CROSS
 export CFG_PREFIX
@@ -332,26 +345,26 @@ ifdef CFG_DISABLE_SHAREDSTD
     $$(TLIB$(1)_T_$(2)_H_$(3))/librustc.rlib
 else
   HCORELIB_DEFAULT$(1)_H_$(3) = \
-    $$(HLIB$(1)_H_$(3))/$(CFG_CORELIB)
+    $$(HLIB$(1)_H_$(3))/$(CFG_CORELIB_$(3))
   TCORELIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
-    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_CORELIB)
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_CORELIB_$(2))
 
   HSTDLIB_DEFAULT$(1)_H_$(3) = \
-    $$(HLIB$(1)_H_$(3))/$(CFG_STDLIB)
+    $$(HLIB$(1)_H_$(3))/$(CFG_STDLIB_$(3))
   TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3) = \
-    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB)
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2))
 
   HLIBRUSTC_DEFAULT$(1)_H_$(3) = \
-    $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTC)
+    $$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTC_$(3))
   TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3) = \
-    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC)
+    $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3))
 endif
 
 # Preqrequisites for using the stageN compiler
 HSREQ$(1)_H_$(3) = \
 	$$(HBIN$(1)_H_$(3))/rustc$$(X) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_RUNTIME) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_RUSTLLVM) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_RUNTIME_$(3)) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_RUSTLLVM_$(3)) \
 	$$(HCORELIB_DEFAULT$(1)_H_$(3)) \
 	$$(HSTDLIB_DEFAULT$(1)_H_$(3)) \
 	$$(HLIBSYNTAX_DEFAULT$(1)_H_$(3)) \
@@ -361,14 +374,14 @@ HSREQ$(1)_H_$(3) = \
 # Prerequisites for using the stageN compiler to build target artifacts
 TSREQ$(1)_T_$(2)_H_$(3) = \
 	$$(HSREQ$(1)_H_$(3)) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUNTIME) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUNTIME_$(2)) \
 	$$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a
 
 # Prerequisites for a working stageN compiler and libraries, for a specific target
 SREQ$(1)_T_$(2)_H_$(3) = \
 	$$(TSREQ$(1)_T_$(2)_H_$(3)) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB)
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_CORELIB_$(2)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(2))
 
 # Prerequisites for a working stageN compiler and libraries, for a specific target
 CSREQ$(1)_T_$(2)_H_$(3) = \
@@ -378,20 +391,20 @@ CSREQ$(1)_T_$(2)_H_$(3) = \
 	$$(HBIN$(1)_H_$(3))/rustdoc$$(X) \
 	$$(HBIN$(1)_H_$(3))/rusti$$(X) \
 	$$(HBIN$(1)_H_$(3))/rust$$(X) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBFUZZER) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUSTPKG) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUSTDOC) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUSTI) \
-	$$(HLIB$(1)_H_$(3))/$$(CFG_LIBRUST) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_CORELIB) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_STDLIB)  \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBSYNTAX)  \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBFUZZER) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTPKG) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTDOC) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTI) \
-	$$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUST)
+	$$(HLIB$(1)_H_$(3))/$(CFG_LIBFUZZER_$(3)) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTPKG_$(3)) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTDOC_$(3)) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUSTI_$(3)) \
+	$$(HLIB$(1)_H_$(3))/$(CFG_LIBRUST_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_CORELIB_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_STDLIB_$(3))  \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3))  \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTC_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBFUZZER_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTPKG_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTDOC_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUSTI_$(3)) \
+	$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBRUST_$(3))
 
 ifeq ($(1),0)
 # Don't run the the stage0 compiler under valgrind - that ship has sailed
@@ -409,7 +422,7 @@ CFGFLAG$(1)_T_$(2)_H_$(3) = stage$(1)
 # if you're building a cross config, the host->* parts are
 # effectively stage1, since it uses the just-built stage0.
 ifeq ($(1),0)
-ifneq ($(strip $(CFG_HOST_TRIPLE)),$(strip $(3)))
+ifneq ($(strip $(CFG_BUILD_TRIPLE)),$(strip $(3)))
 CFGFLAG$(1)_T_$(2)_H_$(3) = stage1
 endif
 endif
@@ -430,7 +443,7 @@ PERF_STAGE$(1)_T_$(2)_H_$(3) := 				\
 
 endef
 
-$(foreach build,$(CFG_TARGET_TRIPLES), \
+$(foreach build,$(CFG_HOST_TRIPLES), \
  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
   $(eval $(foreach stage,$(STAGES), \
    $(eval $(call SREQ,$(stage),$(target),$(build))))))))
@@ -451,13 +464,13 @@ rustc-stage$(2)-H-$(1):							\
 
 endef
 
-$(foreach host,$(CFG_TARGET_TRIPLES),							\
+$(foreach host,$(CFG_HOST_TRIPLES),							\
  $(eval $(foreach stage,1 2 3,									\
   $(eval $(call DEF_RUSTC_STAGE_TARGET,$(host),$(stage))))))
 
-rustc-stage1: rustc-stage1-H-$(CFG_HOST_TRIPLE)
-rustc-stage2: rustc-stage2-H-$(CFG_HOST_TRIPLE)
-rustc-stage3: rustc-stage3-H-$(CFG_HOST_TRIPLE)
+rustc-stage1: rustc-stage1-H-$(CFG_BUILD_TRIPLE)
+rustc-stage2: rustc-stage2-H-$(CFG_BUILD_TRIPLE)
+rustc-stage3: rustc-stage3-H-$(CFG_BUILD_TRIPLE)
 
 define DEF_RUSTC_TARGET
 # $(1) == architecture
@@ -468,12 +481,12 @@ endef
 $(foreach host,$(CFG_TARGET_TRIPLES),			\
  $(eval $(call DEF_RUSTC_TARGET,$(host))))
 
-rustc-stage1: rustc-stage1-H-$(CFG_HOST_TRIPLE)
-rustc-stage2: rustc-stage2-H-$(CFG_HOST_TRIPLE)
-rustc-stage3: rustc-stage3-H-$(CFG_HOST_TRIPLE)
-rustc: rustc-H-$(CFG_HOST_TRIPLE)
+rustc-stage1: rustc-stage1-H-$(CFG_BUILD_TRIPLE)
+rustc-stage2: rustc-stage2-H-$(CFG_BUILD_TRIPLE)
+rustc-stage3: rustc-stage3-H-$(CFG_BUILD_TRIPLE)
+rustc: rustc-H-$(CFG_BUILD_TRIPLE)
 
-rustc-H-all: $(foreach host,$(CFG_TARGET_TRIPLES),rustc-H-$(host))
+rustc-H-all: $(foreach host,$(CFG_HOST_TRIPLES),rustc-H-$(host))
 
 ######################################################################
 # Entrypoint rule
@@ -489,19 +502,27 @@ CFG_INFO := $(info cfg: *** stage2 and later will not be built ***)
 CFG_INFO := $(info cfg:)
 
 #XXX This is surely busted
-all: $(SREQ1$(CFG_HOST_TRIPLE)) $(GENERATED) docs
+all: $(SREQ1$(CFG_BUILD_TRIPLE)) $(GENERATED) docs
 
 else
 
 define ALL_TARGET_N
+ifneq ($$(findstring $(1),$$(CFG_HOST_TRIPLES)),)
+# 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_TRIPLES), \
- $(eval $(call ALL_TARGET_N,$(target),$(CFG_HOST_TRIPLE))))
+ $(foreach host,$(CFG_HOST_TRIPLES), \
+ $(eval $(call ALL_TARGET_N,$(target),$(host)))))
 
 ALL_TARGET_RULES = $(foreach target,$(CFG_TARGET_TRIPLES), \
- all-target-$(target)-host-$(CFG_HOST_TRIPLE))
+	$(foreach host,$(CFG_HOST_TRIPLES), \
+ all-target-$(target)-host-$(host)))
 
 all: $(ALL_TARGET_RULES) $(GENERATED) docs