rust/mk/stage0.mk

# FIXME: temporary hack: stdlib comes in the lib/ directory, but we want it in
# the base directory, so we move it out.
stage0/rustc$(X): $(S)src/snapshots.txt $(S)src/etc/get-snapshot.py $(MKFILES)
	@$(call E, fetch: $@)
	$(Q)$(S)src/etc/get-snapshot.py
	$(Q)mv stage0/lib/$(CFG_STDLIB) stage0/$(CFG_STDLIB)
	$(Q)touch $@

# Host libs will be made in the process of making rustc above.

# FIXME: temporary hack: the runtime is currently carried in
# lib/ directory only, so we copy it out.

stage0/$(CFG_RUNTIME): stage0/lib/$(CFG_RUNTIME)
	$(Q)cp $< $@

stage0/$(CFG_STDLIB): stage0/rustc$(X)
	$(Q)touch $@

stage0/$(CFG_RUSTLLVM): stage0/rustc$(X)
	$(Q)touch $@

# Target libs will be made in the process of making rustc above.

stage0/lib/glue.o: stage0/rustc$(X)
	$(Q)touch $@

# FIXME: temporary hack: currently not distributing main.o like we should;
# copying from rt

stage0/lib/main.o: rt/main.o
	$(Q)cp $< $@


stage0/lib/$(CFG_RUNTIME): stage0/rustc$(X)
	$(Q)touch $@

# Instantiate template (in stageN.mk) for building
# stage0/lib/$(CFG_STDLIB) and stage0/lib/libstd.rlib.
SREQpre = stage0/lib/main.o $(MKFILES)
$(eval $(call STDLIBGEN,pre,0))
Build stage0/lib/libstd.so using the stage0 compiler. This essentially starts the bootstrapping one step earlier by building the stdlib from source using the stage0 compiler and then using that stdlib to build the stage1 compiler. (Instead of starting by building the stage1 compiler and then building a stdlib with it). This means we should now be able to add features to the stdlib and use them in the compiler without having to do a snapshot. (On the flip side, this means that we now need to do a snapshot if we want to use a new language feature in the stdlib, but that doesn't really seem too burdensome (we already need to snapshot if we want to use a new language feature in the compiler)). 2011-07-20 18:32:53 -05:00			`# FIXME: temporary hack: stdlib comes in the lib/ directory, but we want it in`
			`# the base directory, so we move it out.`
Register new snapshots New snapshots also include rt and rustllvm 2011-07-07 18:40:58 -05:00			`stage0/rustc$(X): $(S)src/snapshots.txt $(S)src/etc/get-snapshot.py $(MKFILES)`
Attempt to shift build to stage0-from-snapshots. 2011-05-03 13:34:44 -05:00			`@$(call E, fetch: $@)`
Remove everything to do with rustboot from makefiles. 2011-05-03 17:51:21 -05:00			`$(Q)$(S)src/etc/get-snapshot.py`
Build stage0/lib/libstd.so using the stage0 compiler. This essentially starts the bootstrapping one step earlier by building the stdlib from source using the stage0 compiler and then using that stdlib to build the stage1 compiler. (Instead of starting by building the stage1 compiler and then building a stdlib with it). This means we should now be able to add features to the stdlib and use them in the compiler without having to do a snapshot. (On the flip side, this means that we now need to do a snapshot if we want to use a new language feature in the stdlib, but that doesn't really seem too burdensome (we already need to snapshot if we want to use a new language feature in the compiler)). 2011-07-20 18:32:53 -05:00			`$(Q)mv stage0/lib/$(CFG_STDLIB) stage0/$(CFG_STDLIB)`
Remove everything to do with rustboot from makefiles. 2011-05-03 17:51:21 -05:00			`$(Q)touch $@`
Start splitting up Makefile.in 2011-05-01 15:18:52 -05:00
Merge the stage1,2,3.mk files into a common definition in stageN.mk, more rearrangement of host/target libs. 2011-07-15 18:12:41 -05:00			`# Host libs will be made in the process of making rustc above.`
Attempt to shift build to stage0-from-snapshots. 2011-05-03 13:34:44 -05:00
Build stage0/lib/libstd.so using the stage0 compiler. This essentially starts the bootstrapping one step earlier by building the stdlib from source using the stage0 compiler and then using that stdlib to build the stage1 compiler. (Instead of starting by building the stage1 compiler and then building a stdlib with it). This means we should now be able to add features to the stdlib and use them in the compiler without having to do a snapshot. (On the flip side, this means that we now need to do a snapshot if we want to use a new language feature in the stdlib, but that doesn't really seem too burdensome (we already need to snapshot if we want to use a new language feature in the compiler)). 2011-07-20 18:32:53 -05:00			`# FIXME: temporary hack: the runtime is currently carried in`
			`# lib/ directory only, so we copy it out.`
Attempt to shift build to stage0-from-snapshots. 2011-05-03 13:34:44 -05:00
Merge the stage1,2,3.mk files into a common definition in stageN.mk, more rearrangement of host/target libs. 2011-07-15 18:12:41 -05:00			`stage0/$(CFG_RUNTIME): stage0/lib/$(CFG_RUNTIME)`
			`$(Q)cp $< $@`
build: Build intrinsics.bc 2011-05-04 20:28:30 -05:00
Build stage0/lib/libstd.so using the stage0 compiler. This essentially starts the bootstrapping one step earlier by building the stdlib from source using the stage0 compiler and then using that stdlib to build the stage1 compiler. (Instead of starting by building the stage1 compiler and then building a stdlib with it). This means we should now be able to add features to the stdlib and use them in the compiler without having to do a snapshot. (On the flip side, this means that we now need to do a snapshot if we want to use a new language feature in the stdlib, but that doesn't really seem too burdensome (we already need to snapshot if we want to use a new language feature in the compiler)). 2011-07-20 18:32:53 -05:00			`stage0/$(CFG_STDLIB): stage0/rustc$(X)`
			`$(Q)touch $@`
Move llvm out of stageN/lib so that the host building stage 1+ can have a newer and incompatible llvm with the bots. 2011-07-11 15:31:47 -05:00
Use new snapshot. 2011-07-11 17:33:17 -05:00			`stage0/$(CFG_RUSTLLVM): stage0/rustc$(X)`
Move llvm out of stageN/lib so that the host building stage 1+ can have a newer and incompatible llvm with the bots. 2011-07-11 15:31:47 -05:00			`$(Q)touch $@`

Merge the stage1,2,3.mk files into a common definition in stageN.mk, more rearrangement of host/target libs. 2011-07-15 18:12:41 -05:00			`# Target libs will be made in the process of making rustc above.`

			`stage0/lib/glue.o: stage0/rustc$(X)`
			`$(Q)touch $@`

			`# FIXME: temporary hack: currently not distributing main.o like we should;`
			`# copying from rt`

			`stage0/lib/main.o: rt/main.o`
			`$(Q)cp $< $@`

Build stage0/lib/libstd.so using the stage0 compiler. This essentially starts the bootstrapping one step earlier by building the stdlib from source using the stage0 compiler and then using that stdlib to build the stage1 compiler. (Instead of starting by building the stage1 compiler and then building a stdlib with it). This means we should now be able to add features to the stdlib and use them in the compiler without having to do a snapshot. (On the flip side, this means that we now need to do a snapshot if we want to use a new language feature in the stdlib, but that doesn't really seem too burdensome (we already need to snapshot if we want to use a new language feature in the compiler)). 2011-07-20 18:32:53 -05:00
Move llvm out of stageN/lib so that the host building stage 1+ can have a newer and incompatible llvm with the bots. 2011-07-11 15:31:47 -05:00			`stage0/lib/$(CFG_RUNTIME): stage0/rustc$(X)`
			`$(Q)touch $@`
Merge the stage1,2,3.mk files into a common definition in stageN.mk, more rearrangement of host/target libs. 2011-07-15 18:12:41 -05:00
Instantiate the stage0/lib/stdlib rules from stage0.mk instead of stageN.mk. 2011-07-21 13:58:01 -05:00			`# Instantiate template (in stageN.mk) for building`
			`# stage0/lib/$(CFG_STDLIB) and stage0/lib/libstd.rlib.`
			`SREQpre = stage0/lib/main.o $(MKFILES)`
			`$(eval $(call STDLIBGEN,pre,0))`
Add support for building with a static libstd for testing static crate support. 2011-07-20 15:02:36 -05:00