Don't check in binaries anymore

.gitignore

@@ -1,7 +1,7 @@
-Gemfile.lock
-
 **/target/*
 **/.gdb_history
+**/kernel8.img
 
+Gemfile.lock
 .bundle
 .vendor

01_wait_forever/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -d in_asm -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -d in_asm -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

01_wait_forever/kernel8.img

@@ -1 +0,0 @@
-_ <03><><EFBFBD><EFBFBD>

02_runtime_init/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -d in_asm -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -d in_asm -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

03_hacky_hello_world/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

03_hacky_hello_world/README.md

@@ -32,7 +32,7 @@ diff -uNr 02_runtime_init/Makefile 03_hacky_hello_world/Makefile
 --- 02_runtime_init/Makefile
 +++ 03_hacky_hello_world/Makefile
 @@ -11,7 +11,7 @@
-     OUTPUT            = kernel8.img
+     KERNEL_BIN        = kernel8.img
      QEMU_BINARY       = qemu-system-aarch64
      QEMU_MACHINE_TYPE = raspi3
 -    QEMU_RELEASE_ARGS = -d in_asm -display none
@@ -41,7 +41,7 @@ diff -uNr 02_runtime_init/Makefile 03_hacky_hello_world/Makefile
      RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
  else ifeq ($(BSP),rpi4)
 @@ -19,7 +19,7 @@
-     OUTPUT            = kernel8.img
+     KERNEL_BIN        = kernel8.img
      QEMU_BINARY       = qemu-system-aarch64
      QEMU_MACHINE_TYPE =
 -    QEMU_RELEASE_ARGS = -d in_asm -display none

04_zero_overhead_abstraction/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

05_safe_globals/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

06_drivers_gpio_uart/Makefile

@@ -8,7 +8,7 @@ BSP ?= rpi3
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -16,7 +16,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -51,14 +51,15 @@ DOCKER_QEMU = $(DOCKER_CMD) $(DOCKER_IMAGE)
 
 EXEC_QEMU = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 
-.PHONY: all doc qemu clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -67,24 +68,24 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

07_uart_chainloader/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -23,7 +23,7 @@ ifeq ($(BSP),rpi3)
     CHAINBOOT_DEMO_PAYLOAD = demo_payload_rpi3.img
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -69,14 +69,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu qemuasm chainboot clippy clean readelf objdump nm \
+    check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -85,11 +87,11 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu qemuasm:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 
-qemuasm: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
+qemuasm: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN) -d in_asm
 endif
 
 chainboot:
@@ -99,16 +101,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

07_uart_chainloader/README.md

@@ -116,7 +116,7 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
 +    CHAINBOOT_DEMO_PAYLOAD = demo_payload_rpi3.img
  else ifeq ($(BSP),rpi4)
      TARGET            = aarch64-unknown-none-softfloat
-     OUTPUT            = kernel8.img
+     KERNEL_BIN        = kernel8.img
 @@ -21,7 +28,8 @@
      QEMU_MACHINE_TYPE =
      QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -127,7 +127,7 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
  endif
 
  # Export for build.rs
-@@ -46,12 +54,22 @@
+@@ -46,12 +54,23 @@
 
  DOCKER_IMAGE         = rustembedded/osdev-utils
  DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
@@ -144,15 +144,16 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
 +    DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
 +endif
 
--.PHONY: all doc qemu clippy clean readelf objdump nm check
+-.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu clippy clean readelf objdump nm check
 +EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 +EXEC_MINIPUSH = ruby ../utils/minipush.rb
 +
-+.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm check
++.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu qemuasm chainboot clippy clean readelf objdump nm \
++    check
 
- all:
- 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-@@ -64,13 +82,19 @@
+ all: $(KERNEL_BIN)
+
+@@ -65,13 +84,19 @@
  	$(DOC_CMD) --document-private-items --open
 
  ifeq ($(QEMU_MACHINE_TYPE),)
@@ -160,11 +161,11 @@ diff -uNr 06_drivers_gpio_uart/Makefile 07_uart_chainloader/Makefile
 +qemu qemuasm:
  	@echo "This board is not yet supported for QEMU."
  else
- qemu: all
- 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+ qemu: $(KERNEL_BIN)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 +
-+qemuasm: all
-+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
++qemuasm: $(KERNEL_BIN)
++	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN) -d in_asm
  endif
 
 +chainboot:

08_timestamps/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -22,7 +22,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -67,14 +67,15 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -83,27 +84,27 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

08_timestamps/README.md

@@ -55,7 +55,7 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
 +    RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
  else ifeq ($(BSP),rpi4)
      TARGET            = aarch64-unknown-none-softfloat
-     OUTPUT            = kernel8.img
+     KERNEL_BIN        = kernel8.img
 @@ -28,8 +27,7 @@
      QEMU_MACHINE_TYPE =
      QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -66,16 +66,17 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
  endif
 
  # Export for build.rs
-@@ -69,7 +67,7 @@
+@@ -69,8 +67,7 @@
  EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
  EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
--.PHONY: all doc qemu qemuasm chainboot clippy clean readelf objdump nm check
-+.PHONY: all doc qemu chainboot clippy clean readelf objdump nm check
+-.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu qemuasm chainboot clippy clean readelf objdump nm \
+-    check
++.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot clippy clean readelf objdump nm check
 
- all:
- 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-@@ -82,18 +80,15 @@
+ all: $(KERNEL_BIN)
+
+@@ -84,18 +81,15 @@
  	$(DOC_CMD) --document-private-items --open
 
  ifeq ($(QEMU_MACHINE_TYPE),)
@@ -83,17 +84,17 @@ diff -uNr 07_uart_chainloader/Makefile 08_timestamps/Makefile
 +qemu:
  	@echo "This board is not yet supported for QEMU."
  else
- qemu: all
- 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+ qemu: $(KERNEL_BIN)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 -
--qemuasm: all
--	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT) -d in_asm
+-qemuasm: $(KERNEL_BIN)
+-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN) -d in_asm
  endif
 
 -chainboot:
 -	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(CHAINBOOT_DEMO_PAYLOAD)
-+chainboot: all
-+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
++chainboot: $(KERNEL_BIN)
++	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
  clippy:
  	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)

09_hw_debug_JTAG/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -24,7 +24,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -78,14 +78,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
+    clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -94,12 +96,12 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -108,9 +110,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -123,16 +124,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

09_hw_debug_JTAG/README.md

@@ -323,7 +323,7 @@ diff -uNr 08_timestamps/Makefile 09_hw_debug_JTAG/Makefile
      LINKER_FILE       = src/bsp/raspberrypi/link.ld
      RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
  endif
-@@ -53,21 +57,28 @@
+@@ -53,21 +57,29 @@
  DOCKER_IMAGE         = rustembedded/osdev-utils
  DOCKER_CMD           = docker run -it --rm -v $(shell pwd):/work/tutorial -w /work/tutorial
  DOCKER_ARG_DIR_UTILS = -v $(shell pwd)/../utils:/work/utils
@@ -348,14 +348,15 @@ diff -uNr 08_timestamps/Makefile 09_hw_debug_JTAG/Makefile
  EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
  EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
--.PHONY: all doc qemu chainboot clippy clean readelf objdump nm check
-+.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+-.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot clippy clean readelf objdump nm check
++.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
++    clean readelf objdump nm check
 
- all:
- 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-@@ -90,6 +101,24 @@
- chainboot: all
- 	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+ all: $(KERNEL_BIN)
+
+@@ -91,6 +103,23 @@
+ chainboot: $(KERNEL_BIN)
+ 	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 +jtagboot:
 +	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -364,9 +365,8 @@ diff -uNr 08_timestamps/Makefile 09_hw_debug_JTAG/Makefile
 +	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 +
 +define gen_gdb
-+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-+    cp $(KERNEL_ELF) kernel_for_jtag
-+    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
++    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
++    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 +endef
 +
 +gdb:

10_privilege_level/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -24,7 +24,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -78,14 +78,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
+    clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -94,12 +96,12 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -108,9 +110,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -123,16 +124,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

11_virtual_memory/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -24,7 +24,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -78,14 +78,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
+    clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -94,12 +96,12 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -108,9 +110,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -123,16 +124,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

12_exceptions_part1_groundwork/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -24,7 +24,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -78,14 +78,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
+    clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -94,12 +96,12 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -108,9 +110,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -123,16 +124,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

13_integrated_testing/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -25,7 +25,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -94,14 +94,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu test chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu test chainboot jtagboot openocd gdb gdb-opt0 \
+    clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -110,8 +112,8 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu test:
 	@echo $(QEMU_MISSING_STRING)
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 
 define KERNEL_TEST_RUNNER
     #!/usr/bin/env bash
@@ -129,8 +131,8 @@ test:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(TEST_CMD) $(TEST_ARG)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -139,9 +141,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -154,16 +155,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

13_integrated_testing/README.md

@@ -886,16 +886,18 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 
      DOCKER_CHAINBOOT = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_IMAGE)
      DOCKER_JTAGBOOT  = $(DOCKER_CMD_DEV) $(DOCKER_ARG_DIR_UTILS) $(DOCKER_ARG_DIR_JTAG) $(DOCKER_IMAGE)
-@@ -78,7 +94,7 @@
+@@ -78,8 +94,8 @@
  EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
  EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
--.PHONY: all doc qemu chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
-+.PHONY: all doc qemu test chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+-.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot jtagboot openocd gdb gdb-opt0  clippy \
+-    clean readelf objdump nm check
++.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu test chainboot jtagboot openocd gdb gdb-opt0 \
++    clippy clean readelf objdump nm check
 
- all:
- 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-@@ -91,11 +107,26 @@
+ all: $(KERNEL_BIN)
+
+@@ -93,11 +109,26 @@
  	$(DOC_CMD) --document-private-items --open
 
  ifeq ($(QEMU_MACHINE_TYPE),)
@@ -904,8 +906,8 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 +qemu test:
 +	@echo $(QEMU_MISSING_STRING)
  else
- qemu: all
- 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+ qemu: $(KERNEL_BIN)
+ 	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 +
 +define KERNEL_TEST_RUNNER
 +    #!/usr/bin/env bash
@@ -923,7 +925,7 @@ diff -uNr 12_exceptions_part1_groundwork/Makefile 13_integrated_testing/Makefile
 +	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(TEST_CMD) $(TEST_ARG)
  endif
 
- chainboot: all
+ chainboot: $(KERNEL_BIN)
 
 diff -uNr 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs 13_integrated_testing/src/_arch/aarch64/cpu.rs
 --- 12_exceptions_part1_groundwork/src/_arch/aarch64/cpu.rs

14_exceptions_part2_peripheral_IRQs/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -25,7 +25,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -95,14 +95,16 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu test chainboot jtagboot openocd gdb gdb-opt0 clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu test chainboot jtagboot openocd gdb gdb-opt0 \
+    clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -112,8 +114,8 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu test:
 	@echo $(QEMU_MISSING_STRING)
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 
 define KERNEL_TEST_RUNNER
     #!/usr/bin/env bash
@@ -132,8 +134,8 @@ test:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(TEST_CMD) $(TEST_ARG)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 jtagboot:
 	@$(DOCKER_JTAGBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(JTAG_BOOT_IMAGE)
@@ -142,9 +144,8 @@ openocd:
 	@$(DOCKER_OPENOCD) openocd $(OPENOCD_ARG)
 
 define gen_gdb
-    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1"  $(RUSTC_CMD)
-    cp $(KERNEL_ELF) kernel_for_jtag
-    @$(DOCKER_GDB) gdb-multiarch -q kernel_for_jtag
+    RUSTFLAGS="$(RUSTFLAGS_PEDANTIC) $1" $(RUSTC_CMD)
+    @$(DOCKER_GDB) gdb-multiarch -q $(KERNEL_ELF)
 endef
 
 gdb:
@@ -157,16 +158,16 @@ clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer

14_exceptions_part2_peripheral_IRQs/README.md

@@ -773,7 +773,7 @@ diff -uNr 13_integrated_testing/Makefile 14_exceptions_part2_peripheral_IRQs/Mak
      --release
 
  RUSTC_CMD   = cargo rustc $(COMPILER_ARGS)
-@@ -106,6 +107,7 @@
+@@ -108,6 +109,7 @@
  doc:
  	$(DOC_CMD) --document-private-items --open
 
@@ -781,7 +781,7 @@ diff -uNr 13_integrated_testing/Makefile 14_exceptions_part2_peripheral_IRQs/Mak
  ifeq ($(QEMU_MACHINE_TYPE),)
  qemu test:
  	@echo $(QEMU_MISSING_STRING)
-@@ -122,6 +124,7 @@
+@@ -124,6 +126,7 @@
  endef
 
  export KERNEL_TEST_RUNNER

X1_JTAG_boot/Makefile

@@ -14,7 +14,7 @@ UNAME_S = $(shell uname -s)
 # BSP-specific arguments
 ifeq ($(BSP),rpi3)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE = raspi3
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -22,7 +22,7 @@ ifeq ($(BSP),rpi3)
     RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
-    OUTPUT            = kernel8.img
+    KERNEL_BIN        = kernel8.img
     QEMU_BINARY       = qemu-system-aarch64
     QEMU_MACHINE_TYPE =
     QEMU_RELEASE_ARGS = -serial stdio -display none
@@ -67,14 +67,15 @@ endif
 EXEC_QEMU     = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE)
 EXEC_MINIPUSH = ruby ../utils/minipush.rb
 
-.PHONY: all doc qemu chainboot clippy clean readelf objdump nm check
+.PHONY: all $(KERNEL_ELF) $(KERNEL_BIN) doc qemu chainboot clippy clean readelf objdump nm check
 
-all:
+all: $(KERNEL_BIN)
+
+$(KERNEL_ELF):
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(RUSTC_CMD)
-	@if [ ! -f kernel ] || [ $(KERNEL_ELF) -nt kernel ]; then \
-	    cp $(KERNEL_ELF) .;                                   \
-	    $(OBJCOPY_CMD) kernel $(OUTPUT);                      \
-	fi
+
+$(KERNEL_BIN): $(KERNEL_ELF)
+	@$(OBJCOPY_CMD) $(KERNEL_ELF) $(KERNEL_BIN)
 
 doc:
 	$(DOC_CMD) --document-private-items --open
@@ -83,27 +84,27 @@ ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:
 	@echo "This board is not yet supported for QEMU."
 else
-qemu: all
-	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(OUTPUT)
+qemu: $(KERNEL_BIN)
+	@$(DOCKER_QEMU) $(EXEC_QEMU) $(QEMU_RELEASE_ARGS) -kernel $(KERNEL_BIN)
 endif
 
-chainboot: all
-	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(OUTPUT)
+chainboot: $(KERNEL_BIN)
+	@$(DOCKER_CHAINBOOT) $(EXEC_MINIPUSH) $(DEV_SERIAL) $(KERNEL_BIN)
 
 clippy:
 	RUSTFLAGS="$(RUSTFLAGS_PEDANTIC)" $(CLIPPY_CMD)
 
 clean:
-	rm -rf target
+	rm -rf target $(KERNEL_BIN)
 
-readelf: all
+readelf: $(KERNEL_ELF)
 	readelf -a $(KERNEL_ELF)
 
-objdump: all
+objdump: $(KERNEL_ELF)
 	rust-objdump --arch-name aarch64 --disassemble --demangle --no-show-raw-insn \
 	    --print-imm-hex $(KERNEL_ELF)
 
-nm: all
+nm: $(KERNEL_ELF)
 	rust-nm --demangle --print-size $(KERNEL_ELF) | sort
 
 # For rust-analyzer