ams: support building unit test programs on windows/linux/macos

.gitignore

@@ -84,6 +84,9 @@ dkms.conf
 
 .**/
 
+# macOS horseshittery
+.DS_Store
+
 # NOTE: make sure to make exceptions to this pattern when needed!
 *.bin
 *.enc

Makefile

@@ -1,186 +1,42 @@
-ifeq ($(strip $(DEVKITPRO)),)
+ATMOSPHERE_BUILD_CONFIGS :=
-$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>devkitPro)
+all: nx_release
-endif
+clean: clean-nx_release
 
-include $(DEVKITPRO)/devkitA64/base_tools
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
 
-TOPTARGETS := all clean dist-no-debug dist
+define ATMOSPHERE_ADD_TARGET
-AMSBRANCH := $(shell git symbolic-ref --short HEAD)
-AMSHASH := $(shell git rev-parse --short HEAD)
-AMSREV := $(AMSBRANCH)-$(AMSHASH)
 
-ifneq (, $(strip $(shell git status --porcelain 2>/dev/null)))
+ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
-    AMSREV := $(AMSREV)-dirty
-endif
 
-COMPONENTS := fusee stratosphere mesosphere exosphere emummc thermosphere troposphere libraries
+$(strip $1):
+	@echo "Building $(strip $1)"
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/atmosphere.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
-all: $(COMPONENTS)
+clean-$(strip $1):
-	$(eval MAJORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MAJOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
+	@echo "Cleaning $(strip $1)"
-		| tr -s [:blank:] \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/atmosphere.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-		| cut -d' ' -f3))
-	$(eval MINORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MINOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval MICROVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MICRO\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval S_MAJORVER = $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval S_MINORVER = $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval S_MICROVER = $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	@python fusee/build_package3.py $(CURDIR) release $(AMSHASH) $(MAJORVER) $(MINORVER) $(MICROVER) 0 $(S_MAJORVER) $(S_MINORVER) $(S_MICROVER) 0
-	@echo "Built package3!"
 
-thermosphere:
+endef
-	$(MAKE) -C thermosphere all
 
-exosphere: thermosphere
+define ATMOSPHERE_ADD_TARGETS
-	$(MAKE) -C exosphere all
 
-stratosphere: exosphere libraries
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
-	$(MAKE) -C stratosphere all
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
+))
 
-mesosphere: exosphere libraries
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	$(MAKE) -C mesosphere all
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
+))
 
-troposphere: stratosphere
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	$(MAKE) -C troposphere all
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
+))
 
-emummc:
+endef
-	$(MAKE) -C emummc all
 
-fusee: exosphere mesosphere stratosphere
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
-	$(MAKE) -C $@ all
 
-libraries:
+clean-all: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
-	$(MAKE) -C libraries all
 
-clean:
+.PHONY: all clean clean-all $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-	$(MAKE) -C fusee clean
-	$(MAKE) -C emummc clean
-	$(MAKE) -C libraries clean
-	$(MAKE) -C exosphere clean
-	$(MAKE) -C thermosphere clean
-	$(MAKE) -C mesosphere clean
-	$(MAKE) -C stratosphere clean
-	rm -rf out
-
-dist-no-debug: all
-	$(eval MAJORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MAJOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval MINORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MINOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval MICROVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MICRO\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval AMSVER = $(MAJORVER).$(MINORVER).$(MICROVER)-$(AMSREV))
-	rm -rf atmosphere-$(AMSVER)
-	rm -rf out
-	mkdir atmosphere-$(AMSVER)
-	mkdir atmosphere-$(AMSVER)/atmosphere
-	mkdir atmosphere-$(AMSVER)/switch
-	mkdir -p atmosphere-$(AMSVER)/atmosphere/fatal_errors
-	mkdir -p atmosphere-$(AMSVER)/atmosphere/config_templates
-	mkdir -p atmosphere-$(AMSVER)/atmosphere/config
-	mkdir -p atmosphere-$(AMSVER)/atmosphere/flags
-	cp fusee/fusee.bin atmosphere-$(AMSVER)/atmosphere/reboot_payload.bin
-	cp fusee/package3 atmosphere-$(AMSVER)/atmosphere/package3
-	cp config_templates/stratosphere.ini atmosphere-$(AMSVER)/atmosphere/config_templates/stratosphere.ini
-	cp config_templates/override_config.ini atmosphere-$(AMSVER)/atmosphere/config_templates/override_config.ini
-	cp config_templates/system_settings.ini atmosphere-$(AMSVER)/atmosphere/config_templates/system_settings.ini
-	cp config_templates/exosphere.ini atmosphere-$(AMSVER)/atmosphere/config_templates/exosphere.ini
-	mkdir -p config_templates/kip_patches
-	cp -r config_templates/kip_patches atmosphere-$(AMSVER)/atmosphere/kip_patches
-	cp -r config_templates/hbl_html atmosphere-$(AMSVER)/atmosphere/hbl_html
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000008
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000000D
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000017
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000002B
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000032
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000034
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000036
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000037
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000003C
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000042
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000420
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000B240
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D609
-	mkdir -p atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D623
-	cp stratosphere/boot2/boot2.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000008/exefs.nsp
-	cp stratosphere/dmnt/dmnt.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000000D/exefs.nsp
-	cp stratosphere/cs/cs.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000017/exefs.nsp
-	cp stratosphere/erpt/erpt.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000002B/exefs.nsp
-	cp stratosphere/eclct.stub/eclct.stub.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000032/exefs.nsp
-	cp stratosphere/fatal/fatal.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000034/exefs.nsp
-	cp stratosphere/creport/creport.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000036/exefs.nsp
-	cp stratosphere/ro/ro.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000037/exefs.nsp
-	cp stratosphere/jpegdec/jpegdec.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000003C/exefs.nsp
-	cp stratosphere/pgl/pgl.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000042/exefs.nsp
-	cp stratosphere/LogManager/LogManager.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/0100000000000420/exefs.nsp
-	cp stratosphere/htc/htc.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000B240/exefs.nsp
-	cp stratosphere/dmnt.gen2/dmnt.gen2.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D609/exefs.nsp
-	cp stratosphere/TioServer/TioServer.nsp atmosphere-$(AMSVER)/stratosphere_romfs/atmosphere/contents/010000000000D623/exefs.nsp
-	@build_romfs atmosphere-$(AMSVER)/stratosphere_romfs atmosphere-$(AMSVER)/atmosphere/stratosphere.romfs
-	rm -r atmosphere-$(AMSVER)/stratosphere_romfs
-	cp troposphere/reboot_to_payload/reboot_to_payload.nro atmosphere-$(AMSVER)/switch/reboot_to_payload.nro
-	cp troposphere/daybreak/daybreak.nro atmosphere-$(AMSVER)/switch/daybreak.nro
-	cd atmosphere-$(AMSVER); zip -r ../atmosphere-$(AMSVER).zip ./*; cd ../;
-	rm -rf atmosphere-$(AMSVER)
-	mkdir out
-	mv atmosphere-$(AMSVER).zip out/atmosphere-$(AMSVER).zip
-	cp fusee/fusee.bin out/fusee.bin
-
-dist: dist-no-debug
-	$(eval MAJORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MAJOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval MINORVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MINOR\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval MICROVER = $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MICRO\b' libraries/libvapours/include/vapours/ams/ams_api_version.h \
-		| tr -s [:blank:] \
-		| cut -d' ' -f3))
-	$(eval AMSVER = $(MAJORVER).$(MINORVER).$(MICROVER)-$(AMSREV))
-	rm -rf atmosphere-$(AMSVER)-debug
-	mkdir atmosphere-$(AMSVER)-debug
-	cp fusee/loader_stub/loader_stub.elf atmosphere-$(AMSVER)-debug/fusee-loader-stub.elf
-	cp fusee/program/program.elf atmosphere-$(AMSVER)-debug/fusee-program.elf
-	cp exosphere/loader_stub/loader_stub.elf atmosphere-$(AMSVER)-debug/exosphere-loader-stub.elf
-	cp exosphere/program/program.elf atmosphere-$(AMSVER)-debug/exosphere-program.elf
-	cp exosphere/warmboot/warmboot.elf atmosphere-$(AMSVER)-debug/exosphere-warmboot.elf
-	cp exosphere/mariko_fatal/mariko_fatal.elf atmosphere-$(AMSVER)-debug/exosphere-mariko-fatal.elf
-	cp exosphere/program/sc7fw/sc7fw.elf atmosphere-$(AMSVER)-debug/exosphere-sc7fw.elf
-	cp exosphere/program/rebootstub/rebootstub.elf atmosphere-$(AMSVER)-debug/exosphere-rebootstub.elf
-	cp mesosphere/kernel_ldr/kernel_ldr.elf atmosphere-$(AMSVER)-debug/kernel_ldr.elf
-	cp mesosphere/kernel/kernel.elf atmosphere-$(AMSVER)-debug/kernel.elf
-	cp stratosphere/ams_mitm/ams_mitm.elf atmosphere-$(AMSVER)-debug/ams_mitm.elf
-	cp stratosphere/boot/boot.elf atmosphere-$(AMSVER)-debug/boot.elf
-	cp stratosphere/boot2/boot2.elf atmosphere-$(AMSVER)-debug/boot2.elf
-	cp stratosphere/creport/creport.elf atmosphere-$(AMSVER)-debug/creport.elf
-	cp stratosphere/dmnt/dmnt.elf atmosphere-$(AMSVER)-debug/dmnt.elf
-	cp stratosphere/eclct.stub/eclct.stub.elf atmosphere-$(AMSVER)-debug/eclct.stub.elf
-	cp stratosphere/erpt/erpt.elf atmosphere-$(AMSVER)-debug/erpt.elf
-	cp stratosphere/fatal/fatal.elf atmosphere-$(AMSVER)-debug/fatal.elf
-	cp stratosphere/jpegdec/jpegdec.elf atmosphere-$(AMSVER)-debug/jpegdec.elf
-	cp stratosphere/loader/loader.elf atmosphere-$(AMSVER)-debug/loader.elf
-	cp stratosphere/ncm/ncm.elf atmosphere-$(AMSVER)-debug/ncm.elf
-	cp stratosphere/pgl/pgl.elf atmosphere-$(AMSVER)-debug/pgl.elf
-	cp stratosphere/pm/pm.elf atmosphere-$(AMSVER)-debug/pm.elf
-	cp stratosphere/ro/ro.elf atmosphere-$(AMSVER)-debug/ro.elf
-	cp stratosphere/sm/sm.elf atmosphere-$(AMSVER)-debug/sm.elf
-	cp stratosphere/spl/spl.elf atmosphere-$(AMSVER)-debug/spl.elf
-	cp troposphere/daybreak/daybreak.elf atmosphere-$(AMSVER)-debug/daybreak.elf
-	cd atmosphere-$(AMSVER)-debug; zip -r ../atmosphere-$(AMSVER)-debug.zip ./*; cd ../;
-	rm -r atmosphere-$(AMSVER)-debug
-	mv atmosphere-$(AMSVER)-debug.zip out/atmosphere-$(AMSVER)-debug.zip
-
-
-.PHONY: $(TOPTARGETS) $(COMPONENTS)

atmosphere.mk

@@ -0,0 +1,167 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/libraries/config/common.mk
+
+# Get Atmosphere version fields
+ATMOSPHERE_MAJOR_VERSION               := $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MAJOR\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+ATMOSPHERE_MINOR_VERSION               := $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MINOR\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+ATMOSPHERE_MICRO_VERSION               := $(shell grep 'define ATMOSPHERE_RELEASE_VERSION_MICRO\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+ATMOSPHERE_SUPPORTED_HOS_MAJOR_VERSION := $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MAJOR\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+ATMOSPHERE_SUPPORTED_HOS_MINOR_VERSION := $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MINOR\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+ATMOSPHERE_SUPPORTED_HOS_MICRO_VERSION := $(shell grep 'define ATMOSPHERE_SUPPORTED_HOS_VERSION_MICRO\b' $(ATMOSPHERE_LIBRARIES_DIR)/libvapours/include/vapours/ams/ams_api_version.h | tr -s [:blank:] | cut -d' ' -f3)
+
+ATMOSPHERE_VERSION := $(ATMOSPHERE_MAJOR_VERSION).$(ATMOSPHERE_MINOR_VERSION).$(ATMOSPHERE_MICRO_VERSION)-$(ATMOSPHERE_GIT_REVISION)
+
+dist: dist-no-debug
+	$(eval DIST_DIR = $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/atmosphere-$(ATMOSPHERE_VERSION)-debug)
+	rm -rf $(DIST_DIR)
+	mkdir $(DIST_DIR)
+	cp $(CURRENT_DIRECTORY)/fusee/loader_stub/$(ATMOSPHERE_BOOT_OUT_DIR)/loader_stub.elf $(DIST_DIR)/fusee-loader-stub.elf
+	cp $(CURRENT_DIRECTORY)/fusee/program/$(ATMOSPHERE_BOOT_OUT_DIR)/program.elf $(DIST_DIR)/fusee-program.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.elf $(DIST_DIR)/exosphere-loader-stub.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/program/$(ATMOSPHERE_OUT_DIR)/program.elf $(DIST_DIR)/exosphere-program.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/warmboot/$(ATMOSPHERE_BOOT_OUT_DIR)/warmboot.elf $(DIST_DIR)/exosphere-warmboot.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/mariko_fatal/$(ATMOSPHERE_OUT_DIR)/mariko_fatal.elf $(DIST_DIR)/exosphere-mariko-fatal.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/program/sc7fw/$(ATMOSPHERE_BOOT_OUT_DIR)/sc7fw.elf $(DIST_DIR)/exosphere-sc7fw.elf
+	cp $(CURRENT_DIRECTORY)/exosphere/program/rebootstub/$(ATMOSPHERE_BOOT_OUT_DIR)/rebootstub.elf $(DIST_DIR)/exosphere-rebootstub.elf
+	cp $(CURRENT_DIRECTORY)/mesosphere/kernel_ldr/$(ATMOSPHERE_OUT_DIR)/kernel_ldr.elf $(DIST_DIR)/kernel_ldr.elf
+	cp $(CURRENT_DIRECTORY)/mesosphere/kernel/$(ATMOSPHERE_OUT_DIR)/kernel.elf $(DIST_DIR)/kernel.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/ams_mitm/$(ATMOSPHERE_OUT_DIR)/ams_mitm.elf $(DIST_DIR)/ams_mitm.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/boot/$(ATMOSPHERE_OUT_DIR)/boot.elf $(DIST_DIR)/boot.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/boot2/$(ATMOSPHERE_OUT_DIR)/boot2.elf $(DIST_DIR)/boot2.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/creport/$(ATMOSPHERE_OUT_DIR)/creport.elf $(DIST_DIR)/creport.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/cs/$(ATMOSPHERE_OUT_DIR)/cs.elf $(DIST_DIR)/cs.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/dmnt/$(ATMOSPHERE_OUT_DIR)/dmnt.elf $(DIST_DIR)/dmnt.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/dmnt.gen2/$(ATMOSPHERE_OUT_DIR)/dmnt.gen2.elf $(DIST_DIR)/dmnt.gen2.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/eclct.stub/$(ATMOSPHERE_OUT_DIR)/eclct.stub.elf $(DIST_DIR)/eclct.stub.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/erpt/$(ATMOSPHERE_OUT_DIR)/erpt.elf $(DIST_DIR)/erpt.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/fatal/$(ATMOSPHERE_OUT_DIR)/fatal.elf $(DIST_DIR)/fatal.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/htc/$(ATMOSPHERE_OUT_DIR)/htc.elf $(DIST_DIR)/htc.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/jpegdec/$(ATMOSPHERE_OUT_DIR)/jpegdec.elf $(DIST_DIR)/jpegdec.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/loader/$(ATMOSPHERE_OUT_DIR)/loader.elf $(DIST_DIR)/loader.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/LogManager/$(ATMOSPHERE_OUT_DIR)/LogManager.elf $(DIST_DIR)/LogManager.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/ncm/$(ATMOSPHERE_OUT_DIR)/ncm.elf $(DIST_DIR)/ncm.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/pgl/$(ATMOSPHERE_OUT_DIR)/pgl.elf $(DIST_DIR)/pgl.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/pm/$(ATMOSPHERE_OUT_DIR)/pm.elf $(DIST_DIR)/pm.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/ro/$(ATMOSPHERE_OUT_DIR)/ro.elf $(DIST_DIR)/ro.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/sm/$(ATMOSPHERE_OUT_DIR)/sm.elf $(DIST_DIR)/sm.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/spl/$(ATMOSPHERE_OUT_DIR)/spl.elf $(DIST_DIR)/spl.elf
+	cp $(CURRENT_DIRECTORY)/stratosphere/TioServer/$(ATMOSPHERE_OUT_DIR)/TioServer.elf $(DIST_DIR)/TioServer.elf
+	cp $(CURRENT_DIRECTORY)/troposphere/daybreak/daybreak.elf $(DIST_DIR)/daybreak.elf
+	cd $(DIST_DIR); zip -r ../atmosphere-$(ATMOSPHERE_VERSION)-debug.zip ./*; cd ../;
+	rm -rf $(DIST_DIR)
+
+dist-no-debug: package3 $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	$(eval DIST_DIR = $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/atmosphere-$(ATMOSPHERE_VERSION))
+	rm -rf $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/*
+	rm -rf $(DIST_DIR)
+	mkdir $(DIST_DIR)
+	mkdir $(DIST_DIR)/atmosphere
+	mkdir $(DIST_DIR)/switch
+	mkdir -p $(DIST_DIR)/atmosphere/fatal_errors
+	mkdir -p $(DIST_DIR)/atmosphere/config_templates
+	mkdir -p $(DIST_DIR)/atmosphere/config
+	mkdir -p $(DIST_DIR)/atmosphere/flags
+	cp fusee/$(ATMOSPHERE_BOOT_OUT_DIR)/fusee.bin $(DIST_DIR)/atmosphere/reboot_payload.bin
+	cp fusee/$(ATMOSPHERE_BOOT_OUT_DIR)/package3 $(DIST_DIR)/atmosphere/package3
+	cp config_templates/stratosphere.ini $(DIST_DIR)/atmosphere/config_templates/stratosphere.ini
+	cp config_templates/override_config.ini $(DIST_DIR)/atmosphere/config_templates/override_config.ini
+	cp config_templates/system_settings.ini $(DIST_DIR)/atmosphere/config_templates/system_settings.ini
+	cp config_templates/exosphere.ini $(DIST_DIR)/atmosphere/config_templates/exosphere.ini
+	mkdir -p config_templates/kip_patches
+	cp -r config_templates/kip_patches $(DIST_DIR)/atmosphere/kip_patches
+	cp -r config_templates/hbl_html $(DIST_DIR)/atmosphere/hbl_html
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000008
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000000D
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000017
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000002B
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000032
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000034
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000036
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000037
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003C
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000042
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000420
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000B240
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000D609
+	mkdir -p $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000D623
+	cp stratosphere/boot2/$(ATMOSPHERE_OUT_DIR)/boot2.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000008/exefs.nsp
+	cp stratosphere/dmnt/$(ATMOSPHERE_OUT_DIR)/dmnt.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000000D/exefs.nsp
+	cp stratosphere/cs/$(ATMOSPHERE_OUT_DIR)/cs.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000017/exefs.nsp
+	cp stratosphere/erpt/$(ATMOSPHERE_OUT_DIR)/erpt.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000002B/exefs.nsp
+	cp stratosphere/eclct.stub/$(ATMOSPHERE_OUT_DIR)/eclct.stub.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000032/exefs.nsp
+	cp stratosphere/fatal/$(ATMOSPHERE_OUT_DIR)/fatal.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000034/exefs.nsp
+	cp stratosphere/creport/$(ATMOSPHERE_OUT_DIR)/creport.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000036/exefs.nsp
+	cp stratosphere/ro/$(ATMOSPHERE_OUT_DIR)/ro.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000037/exefs.nsp
+	cp stratosphere/jpegdec/$(ATMOSPHERE_OUT_DIR)/jpegdec.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000003C/exefs.nsp
+	cp stratosphere/pgl/$(ATMOSPHERE_OUT_DIR)/pgl.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000042/exefs.nsp
+	cp stratosphere/LogManager/$(ATMOSPHERE_OUT_DIR)/LogManager.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/0100000000000420/exefs.nsp
+	cp stratosphere/htc/$(ATMOSPHERE_OUT_DIR)/htc.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000B240/exefs.nsp
+	cp stratosphere/dmnt.gen2/$(ATMOSPHERE_OUT_DIR)/dmnt.gen2.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000D609/exefs.nsp
+	cp stratosphere/TioServer/$(ATMOSPHERE_OUT_DIR)/TioServer.nsp $(DIST_DIR)/stratosphere_romfs/atmosphere/contents/010000000000D623/exefs.nsp
+	@build_romfs $(DIST_DIR)/stratosphere_romfs $(DIST_DIR)/atmosphere/stratosphere.romfs
+	rm -r $(DIST_DIR)/stratosphere_romfs
+	cp troposphere/reboot_to_payload/reboot_to_payload.nro $(DIST_DIR)/switch/reboot_to_payload.nro
+	cp troposphere/daybreak/daybreak.nro $(DIST_DIR)/switch/daybreak.nro
+	cd $(DIST_DIR); zip -r ../atmosphere-$(ATMOSPHERE_VERSION).zip ./*; cd ../;
+	rm -rf $(DIST_DIR)
+	cp fusee/$(ATMOSPHERE_BOOT_OUT_DIR)/fusee.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/fusee.bin
+
+package3: emummc fusee stratosphere mesosphere exosphere troposphere
+	@python fusee/build_package3.py $(CURRENT_DIRECTORY) $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BOOT_OUT_DIR) $(ATMOSPHERE_GIT_HASH) $(ATMOSPHERE_MAJOR_VERSION) $(ATMOSPHERE_MINOR_VERSION) $(ATMOSPHERE_MICRO_VERSION) 0 $(ATMOSPHERE_SUPPORTED_HOS_MAJOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MINOR_VERSION) $(ATMOSPHERE_SUPPORTED_HOS_MICRO_VERSION) 0
+	@echo "Built package3!"
+
+emummc:
+	$(MAKE) -C $(CURRENT_DIRECTORY)/emummc all
+
+fusee: libexosphere_boot
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/fusee -f $(CURRENT_DIRECTORY)/fusee/fusee.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+
+exosphere: libexosphere libexosphere_boot
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/exosphere -f $(CURRENT_DIRECTORY)/exosphere/exosphere.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1
+
+stratosphere: fusee libstratosphere
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/stratosphere -f $(CURRENT_DIRECTORY)/stratosphere/stratosphere.mk ATMOSPHERE_CHECKED_LIBSTRATOSPHERE=1 ATMOSPHERE_CHECKED_FUSEE=1
+
+mesosphere: libmesosphere
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/mesosphere -f $(CURRENT_DIRECTORY)/mesosphere/mesosphere.mk ATMOSPHERE_CHECKED_LIBMESOSPHERE=1
+
+troposphere:
+	$(MAKE) -C $(CURRENT_DIRECTORY)/troposphere all
+
+libexosphere:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+
+ifneq ($(strip $(ATMOSPHERE_LIBRARY_DIR)),$(strip $(ATMOSPHERE_BOOT_LIBRARY_DIR)))
+libexosphere_boot:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+else
+libexosphere_boot: libexosphere
+endif
+
+libmesosphere:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libmesosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libmesosphere/libmesosphere.mk
+
+libstratosphere:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/libstratosphere.mk
+
+clean:
+	$(MAKE) -C $(CURRENT_DIRECTORY)/fusee -f $(CURRENT_DIRECTORY)/fusee/fusee.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	$(MAKE) -C $(CURRENT_DIRECTORY)/emummc clean
+	$(MAKE) -C $(CURRENT_DIRECTORY)/exosphere -f $(CURRENT_DIRECTORY)/exosphere/exosphere.mk clean
+	$(MAKE) -C $(CURRENT_DIRECTORY)/mesosphere -f $(CURRENT_DIRECTORY)/mesosphere/mesosphere.mk clean
+	$(MAKE) -C $(CURRENT_DIRECTORY)/stratosphere -f $(CURRENT_DIRECTORY)/stratosphere/stratosphere.mk clean
+	$(MAKE) -C $(CURRENT_DIRECTORY)/troposphere clean
+	$(MAKE) -C $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/libstratosphere.mk clean
+	$(MAKE) -C $(ATMOSPHERE_LIBRARIES_DIR)/libmesosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libmesosphere/libmesosphere.mk clean
+	$(MAKE) -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean
+	$(MAKE) -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	rm -rf $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+
+$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR) $(CURRENT_DIRECTORY)/$(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+.PHONY: dist dist-no-debug clean package3 emummc fusee stratosphere mesosphere exosphere troposphere

exosphere/Makefile

@@ -1,75 +1,41 @@
 ATMOSPHERE_BUILD_CONFIGS :=
-all: release
+all: nx_release
+
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): exosphere$(strip $2).bin warmboot$(strip $2).bin mariko_fatal$(strip $2).bin
+$(strip $1):
+	@echo "Building $(strip $1)"
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/exosphere.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
-exosphere$(strip $2).bin: loader_stub/loader_stub$(strip $2).bin
+clean-$(strip $1):
-	@cp loader_stub/loader_stub$(strip $2).bin exosphere$(strip $2).bin
+	@echo "Cleaning $(strip $1)"
-	@printf LENY >> exosphere$(strip $2).bin
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/exosphere.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	@echo "Built exosphere$(strip $2).bin..."
-
-warmboot$(strip $2).bin: warmboot/warmboot$(strip $2).bin
-	@cp warmboot/warmboot$(strip $2).bin warmboot$(strip $2).bin
-	@echo "Built warmboot$(strip $2).bin..."
-
-mariko_fatal$(strip $2).bin: mariko_fatal/mariko_fatal$(strip $2).bin
-	@cp mariko_fatal/mariko_fatal$(strip $2).bin mariko_fatal$(strip $2).bin
-	@echo "Built mariko_fatal$(strip $2).bin..."
-
-check_program_$(strip $1):
-	@$$(MAKE) -C program $(strip $1)
-
-check_warmboot_$(strip $1):
-	@$$(MAKE) -C warmboot $(strip $1)
-
-check_mariko_fatal_$(strip $1):
-	@$$(MAKE) -C mariko_fatal $(strip $1)
-
-loader_stub/loader_stub$(strip $2).bin: check_program_$(strip $1)
-	@$$(MAKE) -C loader_stub $(strip $1)
-
-warmboot/warmboot$(strip $2).bin: check_warmboot_$(strip $1)
-
-mariko_fatal/mariko_fatal$(strip $2).bin: check_mariko_fatal_$(strip $1)
-
-clean-$(strip $1): clean-program-$(strip $1) clean-loader_stub-$(strip $1) clean-warmboot-$(strip $1) clean-mariko_fatal-$(strip $1)
-	@rm -rf exosphere$(strip $2).bin warmboot$(strip $2).bin mariko_fatal$(strip $2).bin
-
-clean-program-$(strip $1):
-	@$$(MAKE) -C program clean-$(strip $1)
-
-clean-loader_stub-$(strip $1):
-	@$$(MAKE) -C loader_stub clean-$(strip $1)
-
-clean-warmboot-$(strip $1):
-	@$$(MAKE) -C warmboot clean-$(strip $1)
-
-clean-mariko_fatal-$(strip $1):
-	@$$(MAKE) -C mariko_fatal clean-$(strip $1)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release, ))
+define ATMOSPHERE_ADD_TARGETS
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug))
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit))
 
-clean: clean-program clean-loader_stub clean-warmboot
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
-	@rm -rf exosphere*.bin warmboot*.bin mariko_fatal*.bin
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
+))
 
-clean-program:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	@$(MAKE) -C program clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
+))
 
-clean-loader_stub:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	@$(MAKE) -C loader_stub clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
+))
 
-clean-warmboot:
+endef
-	@$(MAKE) -C warmboot clean
 
-clean-mariko_fatal:
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
-	@$(MAKE) -C mariko_fatal clean
 
-.PHONY: all clean clean-program clean-loader_stub clean-warmboot $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),check_program_$(config) check_warmboot_$(strip $1) clean-$(config) clean-program-$(config) clean-loader_stub-$(config) clean-warmboot-$(config))
+clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
+
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))

exosphere/exosphere.mk

@@ -0,0 +1,75 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../libraries/config/common.mk
+
+all: $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/exosphere.bin $(CURRENT_DIRECTORY)/warmboot/$(ATMOSPHERE_BOOT_OUT_DIR)/warmboot.bin $(CURRENT_DIRECTORY)/mariko_fatal/$(ATMOSPHERE_OUT_DIR)/mariko_fatal.bin
+
+$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/exosphere.bin: $(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@cp $(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/exosphere.bin
+	@printf LENY >> $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/exosphere.bin
+	@echo "Built exosphere.bin..."
+
+$(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin: check_loader_stub
+	@$(SILENTCMD)echo "Checked loader stub."
+
+$(CURRENT_DIRECTORY)/program/$(ATMOSPHERE_OUT_DIR)/program.lz4: check_program
+	@$(SILENTCMD)echo "Checked program."
+
+$(CURRENT_DIRECTORY)/warmboot/$(ATMOSPHERE_BOOT_OUT_DIR)/warmboot.bin: check_warmboot
+	@$(SILENTCMD)echo "Checked warmboot."
+
+$(CURRENT_DIRECTORY)/mariko_fatal/$(ATMOSPHERE_OUT_DIR)/mariko_fatal.bin: check_mariko_fatal
+	@$(SILENTCMD)echo "Checked mariko fatal."
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifneq ($(strip $(ATMOSPHERE_LIBRARY_DIR)),$(strip $(ATMOSPHERE_BOOT_LIBRARY_DIR)))
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a: check_boot_lib
+	@$(SILENTCMD)echo "Checked boot library."
+endif
+
+check_loader_stub: $(CURRENT_DIRECTORY)/program/$(ATMOSPHERE_OUT_DIR)/program.lz4
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/loader_stub -f $(CURRENT_DIRECTORY)/loader_stub/loader_stub.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_EXOSPHERE_PROGRAM=1
+
+check_program: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/program -f $(CURRENT_DIRECTORY)/program/program.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1
+
+check_mariko_fatal: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/mariko_fatal -f $(CURRENT_DIRECTORY)/mariko_fatal/mariko_fatal.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1
+
+check_warmboot: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/warmboot -f $(CURRENT_DIRECTORY)/warmboot/warmboot.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1 ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE),1)
+check_boot_lib:
+else
+check_boot_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+endif
+
+$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+clean:
+	@echo clean ...
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/loader_stub -f $(CURRENT_DIRECTORY)/loader_stub/loader_stub.mk clean
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/program -f $(CURRENT_DIRECTORY)/program/program.mk clean
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/mariko_fatal -f $(CURRENT_DIRECTORY)/mariko_fatal/mariko_fatal.mk clean
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/warmboot -f $(CURRENT_DIRECTORY)/warmboot/warmboot.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	@rm -fr $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
+
+.PHONY: all clean check_lib check_boot_lib check_loader_stub check_program check_mariko_fatal check_warmboot

exosphere/loader_stub/Makefile

@@ -1,158 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm-cortex-a57
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:= $(OFILES_SRC) program.lz4.o boot_code.lz4.o
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	ATMOSPHERE_BUILD_TARGET_IDENTIFIER=$(strip $1)\
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/loader_stub.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX=$(strip $2)\
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf $$(OUTPUT_BASE)$(strip $2).lz4 boot_code$(strip $2).lz4
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/loader_stub.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-
-program.lz4.o: program_lz4.h
-
-program_lz4.h:	$(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4
-	@echo $(notdir $<)
-	@rm -rf tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@mkdir -p tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@cp $(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4 tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/program.lz4
-	@bin2s -a 8 -H program_lz4.h tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/program.lz4 | $(AS) -o program.lz4.o
-	@rm -rf tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-$(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4:
-	@$(MAKE) __RECURSIVE__=0 --no-print-directory -C $(TOPDIR)/../program $(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-boot_code.lz4.o: boot_code_lz4.h
-
-boot_code_lz4.h:	$(TOPDIR)/../program/boot_code$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4
-	@echo $(notdir $<)
-	@rm -rf tmp_boot_code_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@mkdir -p tmp_boot_code_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@cp $(TOPDIR)/../program/boot_code$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4 tmp_boot_code_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/boot_code.lz4
-	@bin2s -a 8 -H boot_code_lz4.h tmp_boot_code_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/boot_code.lz4 | $(AS) -o boot_code.lz4.o
-	@rm -rf tmp_boot_code_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-$(TOPDIR)/../program/boot_code$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4: $(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: program_lz4.h boot_code_lz4.h
-
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/loader_stub/loader_stub.mk

@@ -0,0 +1,132 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir)) \
+            $(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    := program.lz4 boot_code.lz4
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib check_exo_program
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a $(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)/program.lz4
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+$(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)/program.lz4: check_exo_program
+	@$(SILENTCMD)echo "Checked exosphere program."
+
+ifeq ($(ATMOSPHERE_CHECKED_EXOSPHERE_PROGRAM),1)
+check_exo_program:
+else
+check_exo_program: check_lib
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/../program -f $(CURRENT_DIRECTORY)/../program/program.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+program.lz4.o: program.lz4
+	@echo $(notdir $<)
+	@$(bin2o)
+
+boot_code.lz4.o: boot_code.lz4
+	@echo $(notdir $<)
+	@$(bin2o)
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(OFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/loader_stub/loader_stub.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /loader_stub.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /loader_stub.ld) --gc-sections --nmagic

exosphere/mariko_fatal/Makefile

@@ -1,141 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm-cortex-a57
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/mariko_fatal.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/mariko_fatal.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-diskio.o ff.o: CFLAGS += -Wno-error
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/mariko_fatal/mariko_fatal.mk

@@ -0,0 +1,115 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    :=
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+diskio.o ff.o: CFLAGS += -Wno-error -Wno-unused-parameter -Wno-implicit-fallthrough
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/mariko_fatal/mariko_fatal.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /mariko_fatal.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /mariko_fatal.ld) --gc-sections --nmagic

exosphere/program/Makefile

@@ -1,163 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm-cortex-a57
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:= $(OFILES_SRC) rebootstub.bin.o sc7fw.bin.o
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	ATMOSPHERE_BUILD_TARGET_IDENTIFIER=$(strip $1)\
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/program.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX=$(strip $2)\
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf $$(OUTPUT_BASE)$(strip $2).lz4 boot_code$(strip $2).lz4
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/program.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).lz4	:	$(OUTPUT).bin
-	@python $(TOPDIR)/split_program.py $(OUTPUT).bin "$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX)" $(dir $(OUTPUT))
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-secmon_crt0_cpp.o secmon_make_page_table.o : CFLAGS += -fno-builtin
-
-rebootstub.bin.o: rebootstub_bin.h
-
-rebootstub_bin.h:	$(TOPDIR)/rebootstub/rebootstub$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin
-	@echo $(notdir $<)
-	@rm -rf tmp_rebootstub_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@mkdir -p tmp_rebootstub_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@cp $(TOPDIR)/rebootstub/rebootstub$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin tmp_rebootstub_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/rebootstub.bin
-	@bin2s -a 8 -H rebootstub_bin.h tmp_rebootstub_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/rebootstub.bin | $(AS) -o rebootstub.bin.o
-	@rm -rf tmp_rebootstub_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-$(TOPDIR)/rebootstub/rebootstub$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin:
-	@$(MAKE) __RECURSIVE__=0 --no-print-directory -C $(TOPDIR)/rebootstub $(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-sc7fw.bin.o: sc7fw_bin.h
-
-sc7fw.bin.o	sc7fw_bin.h:	$(TOPDIR)/sc7fw/sc7fw$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin
-	@echo $(notdir $<)
-	@rm -rf tmp_sc7fw_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@mkdir -p tmp_sc7fw_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@cp $(TOPDIR)/sc7fw/sc7fw$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin tmp_sc7fw_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/sc7fw.bin
-	@bin2s -a 8 -H sc7fw_bin.h tmp_sc7fw_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/sc7fw.bin | $(AS) -o sc7fw.bin.o
-	@rm -rf tmp_sc7fw_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-$(TOPDIR)/sc7fw/sc7fw$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).bin:
-	@$(MAKE) __RECURSIVE__=0 --no-print-directory -C $(TOPDIR)/sc7fw $(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: rebootstub_bin.h sc7fw_bin.h
-
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/program/program.mk

@@ -0,0 +1,162 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir)) \
+            $(CURRENT_DIRECTORY)/sc7fw/$(ATMOSPHERE_BOOT_OUT_DIR) \
+            $(CURRENT_DIRECTORY)/rebootstub/$(ATMOSPHERE_BOOT_OUT_DIR)
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    := sc7fw.bin rebootstub.bin
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib check_boot_lib check_sc7fw check_rebootstub
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a $(CURRENT_DIRECTORY)/sc7fw/$(ATMOSPHERE_BOOT_OUT_DIR)/sc7fw.bin $(CURRENT_DIRECTORY)/rebootstub/$(ATMOSPHERE_BOOT_OUT_DIR)/rebootstub.bin
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+
+ifneq ($(strip $(ATMOSPHERE_LIBRARY_DIR)),$(strip $(ATMOSPHERE_BOOT_LIBRARY_DIR)))
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a: check_boot_lib
+	@$(SILENTCMD)echo "Checked boot library."
+endif
+
+$(CURRENT_DIRECTORY)/sc7fw/$(ATMOSPHERE_BOOT_OUT_DIR)/sc7fw.bin: check_sc7fw
+
+$(CURRENT_DIRECTORY)/rebootstub/$(ATMOSPHERE_BOOT_OUT_DIR)/rebootstub.bin: check_rebootstub
+
+ifeq ($(ATMOSPHERE_CHECKED_SC7FW),1)
+check_sc7fw:
+else
+check_sc7fw: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/sc7fw -f $(CURRENT_DIRECTORY)/sc7fw/sc7fw.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))" ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_REBOOTSTUB),1)
+check_rebootstub:
+else
+check_rebootstub: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_BOOT_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/rebootstub -f $(CURRENT_DIRECTORY)/rebootstub/rebootstub.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))" ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE=1
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_BOOT_LIBEXOSPHERE),1)
+check_boot_lib:
+else
+check_boot_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/rebootstub -f $(CURRENT_DIRECTORY)/rebootstub/rebootstub.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/sc7fw -f $(CURRENT_DIRECTORY)/sc7fw/sc7fw.mk clean ATMOSPHERE_CPU="$(strip $(ATMOSPHERE_BOOT_CPU))"
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).lz4	:	$(OUTPUT).bin
+	@python $(CURRENT_DIRECTORY)/split_program.py $(OUTPUT).bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+secmon_crt0_cpp.o secmon_make_page_table.o : CFLAGS += -fno-builtin
+
+sc7fw.bin.o: sc7fw.bin
+	@echo $(notdir $<)
+	@$(bin2o)
+
+rebootstub.bin.o: rebootstub.bin
+	@echo $(notdir $<)
+	@$(bin2o)
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(OFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/program/program.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /program.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /program.ld) --gc-sections --nmagic

exosphere/program/rebootstub/Makefile

@@ -1,139 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/rebootstub.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/rebootstub.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/program/rebootstub/rebootstub.mk

@@ -0,0 +1,113 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    :=
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/program/rebootstub/rebootstub.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /rebootstub.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /rebootstub.ld) --gc-sections --nmagic

exosphere/program/sc7fw/Makefile

@@ -1,139 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/sc7fw.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/sc7fw.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/program/sc7fw/sc7fw.mk

@@ -0,0 +1,113 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    :=
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/program/sc7fw/sc7fw.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /sc7fw.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /sc7fw.ld) --gc-sections --nmagic

exosphere/program/source/smc/secmon_smc_power_management.cpp

@@ -408,6 +408,7 @@ namespace ams::secmon::smc {
             /* Log our suspension. */
             /* NOTE: Nintendo only does this on dev, but we will always do it. */
             if (true /* !pkg1::IsProduction() */) {
+                log::Initialize(secmon::GetLogPort(), secmon::GetLogBaudRate(), secmon::GetLogFlags());
                 log::SendText("OYASUMI\n", 8);
                 log::Flush();
             }

exosphere/program/split_program.py

@@ -20,17 +20,17 @@ def split_binary(data):
     #print ('%X %X %X %X' % (START, BOOT_CODE_START, BOOT_CODE_END, PROGRAM_START))
     boot_code = data[BOOT_CODE_START - START:BOOT_CODE_END - BOOT_CODE_START]
     program   = data[PROGRAM_START   - START:]
-    return [('boot_code%s.lz4', lz4_compress(boot_code)), ('program%s.lz4', lz4_compress(program))]
+    return [('boot_code.lz4', lz4_compress(boot_code)), ('program.lz4', lz4_compress(program))]
 
 def main(argc, argv):
-    if argc != 4:
+    if argc != 3:
-        print('Usage: %s in suffix outdir' % argv[0])
+        print('Usage: %s in outdir' % argv[0])
         return 1
     with open(argv[1], 'rb') as f:
         data = f.read()
     assert len(data) >= 0x40
     for (fn, fdata) in split_binary(data):
-        with open('%s/%s' % (argv[3], fn % argv[2]), 'wb') as f:
+        with open('%s/%s' % (argv[2], fn), 'wb') as f:
             f.write(fdata)
     return 0
 

exosphere/warmboot/Makefile

@@ -1,139 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/warmboot.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/warmboot.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

exosphere/warmboot/warmboot.mk

@@ -0,0 +1,113 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    :=
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

exosphere/warmboot/warmboot.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /warmboot.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /warmboot.ld) --gc-sections --nmagic

fusee/Makefile

@@ -1,44 +1,41 @@
 ATMOSPHERE_BUILD_CONFIGS :=
-all: release
+all: nx_release
+
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): fusee$(strip $2).bin
+$(strip $1):
+	@echo "Building $(strip $1)"
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/fusee.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
-fusee$(strip $2).bin: loader_stub/loader_stub$(strip $2).bin
+clean-$(strip $1):
-	@cp loader_stub/loader_stub$(strip $2).bin fusee$(strip $2).bin
+	@echo "Cleaning $(strip $1)"
-	@echo "Built fusee$(strip $2).bin..."
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/fusee.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-
-check_program_$(strip $1):
-	@$$(MAKE) -C program $(strip $1)
-
-loader_stub/loader_stub$(strip $2).bin: check_program_$(strip $1)
-	@$$(MAKE) -C loader_stub $(strip $1)
-
-clean-$(strip $1): clean-program-$(strip $1) clean-loader_stub-$(strip $1)
-	@rm -rf fusee$(strip $2).bin
-
-clean-program-$(strip $1):
-	@$$(MAKE) -C program clean-$(strip $1)
-
-clean-loader_stub-$(strip $1):
-	@$$(MAKE) -C loader_stub clean-$(strip $1)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release, ))
+define ATMOSPHERE_ADD_TARGETS
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug))
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit))
 
-clean: clean-program clean-loader_stub
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
-	@rm -rf fusee*.bin package3*
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
+))
 
-clean-program:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	@$(MAKE) -C program clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
+))
 
-clean-loader_stub:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	@$(MAKE) -C loader_stub clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
+))
 
-.PHONY: all clean clean-program clean-loader_stub $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),check_program_$(config) check_warmboot_$(strip $1) clean-$(config) clean-program-$(config) clean-loader_stub-$(config) clean-warmboot-$(config))
+endef
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
+
+clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
+
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))

fusee/build_package3.py

@@ -22,15 +22,15 @@ def get_overlay(program, i):
 
 KIP_NAMES = [b'Loader', b'NCM', b'ProcessManager', b'sm', b'boot', b'spl', b'ams_mitm']
 
-def get_kips(ams_dir):
+def get_kips(ams_dir, build_out_dir):
     emummc   = read_file(os.path.join(ams_dir, 'emummc/emummc_unpacked.kip'))
-    loader   = read_file(os.path.join(ams_dir, 'stratosphere/loader/loader.kip'))
+    loader   = read_file(os.path.join(ams_dir, 'stratosphere/loader/%s/loader.kip' % build_out_dir))
-    ncm      = read_file(os.path.join(ams_dir, 'stratosphere/ncm/ncm.kip'))
+    ncm      = read_file(os.path.join(ams_dir, 'stratosphere/ncm/%s/ncm.kip' % build_out_dir))
-    pm       = read_file(os.path.join(ams_dir, 'stratosphere/pm/pm.kip'))
+    pm       = read_file(os.path.join(ams_dir, 'stratosphere/pm/%s/pm.kip' % build_out_dir))
-    sm       = read_file(os.path.join(ams_dir, 'stratosphere/sm/sm.kip'))
+    sm       = read_file(os.path.join(ams_dir, 'stratosphere/sm/%s/sm.kip' % build_out_dir))
-    boot     = read_file(os.path.join(ams_dir, 'stratosphere/boot/boot.kip'))
+    boot     = read_file(os.path.join(ams_dir, 'stratosphere/boot/%s/boot.kip' % build_out_dir))
-    spl      = read_file(os.path.join(ams_dir, 'stratosphere/spl/spl.kip'))
+    spl      = read_file(os.path.join(ams_dir, 'stratosphere/spl/%s/spl.kip' % build_out_dir))
-    ams_mitm = read_file(os.path.join(ams_dir, 'stratosphere/ams_mitm/ams_mitm.kip'))
+    ams_mitm = read_file(os.path.join(ams_dir, 'stratosphere/ams_mitm/%s/ams_mitm.kip' % build_out_dir))
     return (emummc, {
         b'Loader' : loader,
         b'NCM' : ncm,
@@ -134,39 +134,40 @@ def write_kips(f, all_kips):
     f.write(b'\xCC' * (0x300000 - tot))
 
 def main(argc, argv):
-    if argc != 12:
+    if argc != 13:
-        print('Usage: %s ams_dir target revision major minor micro relstep s_major s_minor s_micro s_relstep' % argv[0])
+        print('Usage: %s ams_dir build_out_dir build_boot_out_dir revision major minor micro relstep s_major s_minor s_micro s_relstep' % argv[0])
         return 1
     # Parse arguments
     ams_dir            = argv[1]
-    target    = '' if argv[2] == 'release' else ('_%s' % argv[2])
+    build_out_dir      = argv[2]
-    revision  = int(argv[3][:8], 16)
+    build_boot_out_dir = argv[3]
-    major     = int(argv[4])
+    revision           = int(argv[4][:8], 16)
-    minor     = int(argv[5])
+    major              = int(argv[5])
-    micro     = int(argv[6])
+    minor              = int(argv[6])
-    relstep   = int(argv[7])
+    micro              = int(argv[7])
-    s_major   = int(argv[8])
+    relstep            = int(argv[8])
-    s_minor   = int(argv[9])
+    s_major            = int(argv[9])
-    s_micro   = int(argv[10])
+    s_minor            = int(argv[10])
-    s_relstep = int(argv[11])
+    s_micro            = int(argv[11])
+    s_relstep          = int(argv[12])
     # Read/parse fusee
-    fusee_program = read_file(os.path.join(ams_dir, 'fusee/program/program%s.bin' % target))
+    fusee_program = read_file(os.path.join(ams_dir, 'fusee/program/%s/program.bin' % build_boot_out_dir))
-    fusee_bin     = read_file(os.path.join(ams_dir, 'fusee/fusee%s.bin' % target))
+    fusee_bin     = read_file(os.path.join(ams_dir, 'fusee/%s/fusee.bin' % build_boot_out_dir))
     erista_mtc = get_overlay(fusee_program, 1)
     mariko_mtc = get_overlay(fusee_program, 2)
     erista_hsh = hashlib.sha256(erista_mtc[:-4]).digest()[:4]
     mariko_hsh = hashlib.sha256(mariko_mtc[:-4]).digest()[:4]
     # Read other files
-    exosphere    = read_file(os.path.join(ams_dir, 'exosphere/exosphere%s.bin' % target))
+    exosphere    = read_file(os.path.join(ams_dir, 'exosphere/%s/exosphere.bin' % build_out_dir))
-    warmboot     = read_file(os.path.join(ams_dir, 'exosphere/warmboot%s.bin' % target))
+    warmboot     = read_file(os.path.join(ams_dir, 'exosphere/warmboot/%s/warmboot.bin' % build_boot_out_dir))
-    mariko_fatal = read_file(os.path.join(ams_dir, 'exosphere/mariko_fatal%s.bin' % target))
+    mariko_fatal = read_file(os.path.join(ams_dir, 'exosphere/mariko_fatal/%s/mariko_fatal.bin' % build_out_dir))
-    rebootstub   = read_file(os.path.join(ams_dir, 'exosphere/program/rebootstub/rebootstub%s.bin' % target))
+    rebootstub   = read_file(os.path.join(ams_dir, 'exosphere/program/rebootstub/%s/rebootstub.bin' % build_boot_out_dir))
-    mesosphere   = read_file(os.path.join(ams_dir, 'mesosphere/mesosphere%s.bin' % target))
+    mesosphere   = read_file(os.path.join(ams_dir, 'mesosphere/%s/mesosphere.bin' % build_out_dir))
-    all_kips     = get_kips(ams_dir)
+    all_kips     = get_kips(ams_dir, build_out_dir)
     tsec_keygen  = read_file(os.path.join(ams_dir, 'fusee/program/tsec_keygen/tsec_keygen.bin'))
     splash_bin   = read_file(os.path.join(ams_dir, 'img/splash.bin'))
     assert len(splash_bin) == 0x3C0000
-    with open(os.path.join(ams_dir, 'fusee/package3%s' % target), 'wb') as f:
+    with open(os.path.join(ams_dir, 'fusee/%s/package3' % build_boot_out_dir), 'wb') as f:
         # Write header
         write_header(f, all_kips, len(warmboot), len(tsec_keygen), len(mariko_fatal), len(exosphere), len(mesosphere), len(fusee_bin), len(rebootstub), revision, major, minor, micro, relstep, s_major, s_minor, s_micro, s_relstep)
         # Write warmboot

fusee/fusee.mk

@@ -0,0 +1,48 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../libraries/config/common.mk
+
+all: $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/fusee.bin
+
+$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/fusee.bin: $(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@cp $(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/fusee.bin
+	@echo "Built fusee.bin..."
+
+$(CURRENT_DIRECTORY)/loader_stub/$(ATMOSPHERE_OUT_DIR)/loader_stub.bin: check_loader_stub
+	@$(SILENTCMD)echo "Checked loader stub."
+
+$(CURRENT_DIRECTORY)/program/$(ATMOSPHERE_OUT_DIR)/program.bin: check_program
+	@$(SILENTCMD)echo "Checked program."
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+check_loader_stub: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a $(CURRENT_DIRECTORY)/program/$(ATMOSPHERE_OUT_DIR)/program.bin
+	@$(SILENTCMD)echo "Checking loader stub..."
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/loader_stub -f $(CURRENT_DIRECTORY)/loader_stub/loader_stub.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1 ATMOSPHERE_CHECKED_FUSEE_PROGRAM=1
+
+check_program: $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(SILENTCMD)echo "Checking program..."
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/program -f $(CURRENT_DIRECTORY)/program/program.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+clean:
+	@echo clean ...
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/loader_stub -f $(CURRENT_DIRECTORY)/loader_stub/loader_stub.mk clean
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/program -f $(CURRENT_DIRECTORY)/program/program.mk clean
+	@rm -fr $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)
+	@for i in $(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
+
+.PHONY: all clean check_lib check_loader_stub check_program

fusee/loader_stub/Makefile

@@ -1,154 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC) program.lz4.o
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	ATMOSPHERE_BUILD_TARGET_IDENTIFIER=$(strip $1) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/loader_stub.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX=$(strip $2) \
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/loader_stub.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-program.lz4.o: program_lz4.h
-
-program_lz4.h:	$(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4
-	@echo $(notdir $<)
-	@rm -rf tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@mkdir -p tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-	@cp $(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4 tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/program.lz4
-	@bin2s -a 8 -H program_lz4.h tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)/program.lz4 | $(AS) -o program.lz4.o
-	@rm -rf tmp_program_$(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-$(TOPDIR)/../program/program$(ATMOSPHERE_BUILD_TARGET_BINARY_SUFFIX).lz4:
-	@$(MAKE) __RECURSIVE__=0 --no-print-directory -C $(TOPDIR)/../program $(ATMOSPHERE_BUILD_TARGET_IDENTIFIER)
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: $(HFILES_BIN) program_lz4.h
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

fusee/loader_stub/loader_stub.mk

@@ -0,0 +1,127 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir)) $(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    := program.lz4
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a $(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)/program.lz4
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+$(CURRENT_DIRECTORY)/../program/$(ATMOSPHERE_OUT_DIR)/program.lz4: check_fusee_program
+	@$(SILENTCMD)echo "Checked fusee program."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+ifeq ($(ATMOSPHERE_CHECKED_FUSEE_PROGRAM),1)
+check_fusee_program:
+else
+check_fusee_program: check_lib
+	@$(MAKE) --no-print-directory -C $(CURRENT_DIRECTORY)/../program -f $(CURRENT_DIRECTORY)/../program/program.mk ATMOSPHERE_CHECKED_LIBEXOSPHERE=1
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+program.lz4.o: program.lz4
+	@echo $(notdir $<)
+	@$(bin2o)
+
+$(OFILES_SRC)	: $(OFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

fusee/loader_stub/loader_stub.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /loader_stub.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /loader_stub.ld) --gc-sections --nmagic

fusee/program/Makefile

@@ -1,144 +1,41 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# Define the atmosphere board and cpu
+all: nx_release
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
 
-#---------------------------------------------------------------------------------
-# pull in common atmosphere configuration
-#---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../../libraries/config/templates/exosphere.mk
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-BINFILES    :=
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
-
-export TOPDIR := $(CURRENT_DIRECTORY)
-
-OUTPUT_BASE := $(TOPDIR)/$(notdir $(TOPDIR))
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): check_libexo_$(strip $1) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1)
+$(strip $1):
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(OUTPUT_BASE)$(strip $2) $(3) \
+	@echo "Building $(strip $1)"
-	ATMOSPHERE_BUILD_TARGET=$(strip $2) \
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/program.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	LIBEXOSPHERE_NAME=exosphere$(strip $2) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-check_libexo_$(strip $1):
-	@$$(MAKE) --no-print-directory -C $$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere $$(ATMOSPHERE_ARCH_NAME)-$(strip $1)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(OUTPUT_BASE)$(strip $2).bin $$(OUTPUT_BASE)$(strip $2).lz4 $$(OUTPUT_BASE)$(strip $2).elf
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/program.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release,     , \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, _debug, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, _audit, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(ATMOSPHERE_BUILD_DIR)/%:
+endef
-	@[ -d $@ ] || mkdir -p $@
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm7tdmi,))
 
-#---------------------------------------------------------------------------------
 clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
 
-.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(config) clean-$(config))
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d)
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-
-$(OUTPUT).lz4	:	$(OUTPUT).bin
-	@python $(TOPDIR)/lz4_compress.py $(OUTPUT).bin $(OUTPUT).lz4
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).bin	:	$(OUTPUT).elf
-	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
-	@echo built ... $(notdir $@)
-
-$(OUTPUT).elf	:	$(OFILES)
-
-$(OFILES)	:	$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/lib$(LIBEXOSPHERE_NAME).a
-
-%.elf:
-	@echo linking $(notdir $@)
-	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
-	@$(NM) -CSn $@ > $(notdir $*.lst)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-#---------------------------------------------------------------------------------
-# you need a rule like this for each extension you use as binary data
-#---------------------------------------------------------------------------------
-%.bin.o	%_bin.h:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------

fusee/program/program.mk

@@ -0,0 +1,117 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../../libraries/config/templates/exosphere.mk
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export ATMOSPHERE_TOPDIR := $(CURRENT_DIRECTORY)
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+BINFILES    :=
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(subst -,_,$(BINFILES))))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/$(ATMOSPHERE_LIBRARY_DIR))
+
+.PHONY: clean all check_lib
+
+#---------------------------------------------------------------------------------
+all: $(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURRENT_DIRECTORY)/$(ATMOSPHERE_OUT_DIR)/$(notdir $(ATMOSPHERE_TOPDIR)) \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+$(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a: check_lib
+	@$(SILENTCMD)echo "Checked library."
+
+ifeq ($(ATMOSPHERE_CHECKED_LIBEXOSPHERE),1)
+check_lib:
+else
+check_lib:
+	@$(MAKE) --no-print-directory -C $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere -f $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/libexosphere.mk
+endif
+
+$(ATMOSPHERE_OUT_DIR) $(ATMOSPHERE_BUILD_DIR):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+
+$(OUTPUT).lz4	:	$(OUTPUT).bin
+	@python $(CURRENT_DIRECTORY)/lz4_compress.py $(OUTPUT).bin $(OUTPUT).lz4
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).bin	:	$(OUTPUT).elf
+	$(OBJCOPY) -S -O binary --set-section-flags .bss=alloc,load,contents $< $@
+	@echo built ... $(notdir $@)
+
+$(OUTPUT).elf	:	$(OFILES)
+
+$(OFILES)	:	 $(ATMOSPHERE_LIBRARIES_DIR)/libexosphere/$(ATMOSPHERE_LIBRARY_DIR)/libexosphere.a
+
+%.elf:
+	@echo linking $(notdir $@)
+	$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
+	@$(NM) -CSn $@ > $(notdir $*.lst)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+#---------------------------------------------------------------------------------
+# you need a rule like this for each extension you use as binary data
+#---------------------------------------------------------------------------------
+%.bin.o	%_bin.h:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------

fusee/program/program.specs

@@ -1,4 +1,4 @@
 %rename link old_link
 
 *link:
-%(old_link) -T %:getenv(TOPDIR /program_ovl.ld) -T %:getenv(TOPDIR /program.ld) --gc-sections --nmagic
+%(old_link) -T %:getenv(ATMOSPHERE_TOPDIR /program_ovl.ld) -T %:getenv(ATMOSPHERE_TOPDIR /program.ld) --gc-sections --nmagic

fusee/program/source/fusee_exception_handler.cpp

@@ -49,6 +49,22 @@ namespace ams::diag {
         nxboot::ShowFatalError("Abort called, lr=%p\n", reinterpret_cast<void *>(lr));
     }
 
+    NORETURN void AssertionFailureImpl(const char *file, int line, const char *func, const char *expr, u64 value) {
+        AMS_UNUSED(file, line, func, expr, value);
+
+        u32 lr;
+        __asm__ __volatile__("mov %0, lr" : "=r"(lr) :: "memory");
+        nxboot::ShowFatalError("Assert called, lr=%p\n", reinterpret_cast<void *>(lr));
+    }
+
+   NORETURN void AssertionFailureImpl(const char *file, int line, const char *func, const char *expr, u64 value, const char *format, ...) {
+        AMS_UNUSED(file, line, func, expr, value, format);
+
+        u32 lr;
+        __asm__ __volatile__("mov %0, lr" : "=r"(lr) :: "memory");
+        nxboot::ShowFatalError("Assert called, lr=%p\n", reinterpret_cast<void *>(lr));
+    }
+
 }
 
 namespace ams::result::impl {

libraries/Makefile

@@ -1,10 +0,0 @@
-ATMOSPHERE_LIBRARIES := libmesosphere libstratosphere libexosphere
-
-TOPTARGETS := all clean
-
-$(TOPTARGETS): $(ATMOSPHERE_LIBRARIES)
-
-$(ATMOSPHERE_LIBRARIES):
-	$(MAKE) -C $@ $(MAKECMDGOALS)
-
-.PHONY: $(TOPTARGETS) $(ATMOSPHERE_LIBRARIES)

libraries/config/arch/arm64/arch.mk

@@ -1,11 +1,23 @@
+ifeq ($(strip $(ATMOSPHERE_OS_NAME)),horizon)
+
 ifeq ($(strip $(DEVKITPRO)),)
 $(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
 endif
 
 include $(DEVKITPRO)/devkitA64/base_rules
 
+else
+
+include $(ATMOSPHERE_ARCH_MAKE_DIR)/base_rules
+
+endif
+
 export ATMOSPHERE_DEFINES  += -DATMOSPHERE_ARCH_ARM64
-export ATMOSPHERE_SETTINGS += -mtp=soft
+export ATMOSPHERE_SETTINGS +=
 export ATMOSPHERE_CFLAGS   +=
 export ATMOSPHERE_CXXFLAGS +=
 export ATMOSPHERE_ASFLAGS  +=
+
+ifeq ($(strip $(ATMOSPHERE_OS_NAME)),horizon)
+export ATMOSPHERE_SETTINGS += -mtp=soft
+endif

libraries/config/arch/arm64/base_rules

@@ -0,0 +1,28 @@
+include $(ATMOSPHERE_ARCH_MAKE_DIR)/base_tools
+
+#---------------------------------------------------------------------------------
+%.a:
+#---------------------------------------------------------------------------------
+	$(SILENTMSG) $(notdir $@)
+	@rm -f $@
+	$(SILENTCMD)$(AR) -rc $@ $^
+
+#---------------------------------------------------------------------------------
+%.o: %.cpp
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CXX) -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.c
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d $(CFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.s
+	@echo $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.S
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)

libraries/config/arch/arm64/base_tools

@@ -0,0 +1,52 @@
+#---------------------------------------------------------------------------------
+# the prefix on the compiler executables
+#---------------------------------------------------------------------------------
+PREFIX		:=
+
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),gcc)
+
+export CC	:=	gcc
+export CXX	:=	g++
+export AS	:=	as
+export AR	:=	gcc-ar
+export OBJCOPY	:=	objcopy
+export STRIP	:=	strip
+export NM	:=	gcc-nm
+export RANLIB	:=	gcc-ranlib
+
+else ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
+
+export CC	:=	clang
+export CXX	:=	clang++
+export AS	:=	llvm-as
+export AR	:=	llvm-ar
+export OBJCOPY	:=	llvm-objcopy
+export STRIP	:=	llvm-strip
+export NM	:=	llvm-nm
+export RANLIB	:=	llvm-ranlib
+
+endif
+
+ISVC=$(or $(VCBUILDHELPER_COMMAND),$(MSBUILDEXTENSIONSPATH32),$(MSBUILDEXTENSIONSPATH))
+
+ifneq (,$(ISVC))
+	ERROR_FILTER	:=	2>&1 | sed -e 's/\(.[a-zA-Z]\+\):\([0-9]\+\):/\1(\2):/g'
+endif
+
+#---------------------------------------------------------------------------------
+# allow seeing compiler command lines with make V=1 (similar to autotools' silent)
+#---------------------------------------------------------------------------------
+ifeq ($(V),1)
+    SILENTMSG := @true
+    SILENTCMD :=
+else
+    SILENTMSG := @echo
+    SILENTCMD := @
+endif
+
+#---------------------------------------------------------------------------------
+# canned command sequence for binary data
+#---------------------------------------------------------------------------------
+define bin2o
+	bin2s -a 8 -H `(echo $(<F) | tr . _)`.h $< | $(AS) -o $(<F).o
+endef

libraries/config/arch/arm64/cpu/generic_arm64/cpu.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_CPU_GENERIC_ARM64
+export ATMOSPHERE_SETTINGS += -march=armv8-a+crc+crypto -mno-outline-atomics
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/arch/x64/arch.mk

@@ -0,0 +1,7 @@
+include $(ATMOSPHERE_ARCH_MAKE_DIR)/base_rules
+
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_ARCH_X64
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/arch/x64/base_rules

@@ -0,0 +1,28 @@
+include $(ATMOSPHERE_ARCH_MAKE_DIR)/base_tools
+
+#---------------------------------------------------------------------------------
+%.a:
+#---------------------------------------------------------------------------------
+	$(SILENTMSG) $(notdir $@)
+	@rm -f $@
+	$(SILENTCMD)$(AR) -rc $@ $^
+
+#---------------------------------------------------------------------------------
+%.o: %.cpp
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CXX) -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.c
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d $(CFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.s
+	@echo $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)
+
+#---------------------------------------------------------------------------------
+%.o: %.S
+	$(SILENTMSG) $(notdir $<)
+	$(SILENTCMD)$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER)

libraries/config/arch/x64/base_tools

@@ -0,0 +1,52 @@
+#---------------------------------------------------------------------------------
+# the prefix on the compiler executables
+#---------------------------------------------------------------------------------
+PREFIX		:=
+
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),gcc)
+
+export CC	:=	gcc
+export CXX	:=	g++
+export AS	:=	as
+export AR	:=	gcc-ar
+export OBJCOPY	:=	objcopy
+export STRIP	:=	strip
+export NM	:=	gcc-nm
+export RANLIB	:=	gcc-ranlib
+
+else ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
+
+export CC	:=	clang
+export CXX	:=	clang++
+export AS	:=	llvm-as
+export AR	:=	llvm-ar
+export OBJCOPY	:=	llvm-objcopy
+export STRIP	:=	llvm-strip
+export NM	:=	llvm-nm
+export RANLIB	:=	llvm-ranlib
+
+endif
+
+ISVC=$(or $(VCBUILDHELPER_COMMAND),$(MSBUILDEXTENSIONSPATH32),$(MSBUILDEXTENSIONSPATH))
+
+ifneq (,$(ISVC))
+	ERROR_FILTER	:=	2>&1 | sed -e 's/\(.[a-zA-Z]\+\):\([0-9]\+\):/\1(\2):/g'
+endif
+
+#---------------------------------------------------------------------------------
+# allow seeing compiler command lines with make V=1 (similar to autotools' silent)
+#---------------------------------------------------------------------------------
+ifeq ($(V),1)
+    SILENTMSG := @true
+    SILENTCMD :=
+else
+    SILENTMSG := @echo
+    SILENTCMD := @
+endif
+
+#---------------------------------------------------------------------------------
+# canned command sequence for binary data
+#---------------------------------------------------------------------------------
+define bin2o
+	bin2s -a 8 -H `(echo $(<F) | tr . _)`.h $< | $(AS) -o $(<F).o
+endef

libraries/config/arch/x64/cpu/generic_x64/cpu.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_CPU_GENERIC_X64
+export ATMOSPHERE_SETTINGS += -march=native -mtune=generic
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/board/generic/linux/board.mk

@@ -0,0 +1,19 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_BOARD_GENERIC_LINUX
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=
+
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
+export ATMOSPHERE_CXXFLAGS += -stdlib=libc++
+
+ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),x64)
+export ATMOSPHERE_SETTINGS += -target x86_64-pc-linux-gnu
+else ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
+export ATMOSPHERE_SETTINGS += -target aarch64-linux-gnu
+endif
+
+endif
+
+# TODO: Better way of doing this?
+export ATMOSPHERE_CXXFLAGS += -I/opt/libjpeg-turbo/include

libraries/config/board/generic/macos/board.mk

@@ -0,0 +1,23 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_BOARD_GENERIC_MACOS
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=
+
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
+export ATMOSPHERE_CXXFLAGS += -stdlib=libc++
+
+ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),x64)
+export ATMOSPHERE_SETTINGS += -target x86_64-apple-darwin
+else ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
+export ATMOSPHERE_SETTINGS += -target aarch64-apple-darwin
+endif
+
+endif
+
+ifeq ($(strip $(SDKROOT)),)
+export SDKROOT := $(shell xcrun --sdk macosx --show-sdk-path)
+endif
+
+# TODO: Better way of doing this?
+export ATMOSPHERE_CXXFLAGS += -I/opt/libjpeg-turbo/include

libraries/config/board/generic/windows/board.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_BOARD_GENERIC_WINDOWS
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/common.mk

@@ -15,14 +15,34 @@ endif
 
 endif
 
+ifeq ($(ATMOSPHERE_BUILD_NAME),)
+export ATMOSPHERE_BUILD_NAME := release
+endif
+
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),)
+
+ifneq ($(strip $(ATMOSPHERE_BOARD)),generic_macos)
+export ATMOSPHERE_COMPILER_NAME := gcc
+else
+export ATMOSPHERE_COMPILER_NAME := clang
+endif
+
+export ATMOSPHERE_BUILD_NAME := release
+endif
+
 ATMOSPHERE_BUILD_SETTINGS ?=
 
 export ATMOSPHERE_DEFINES  := -DATMOSPHERE
 export ATMOSPHERE_SETTINGS := -fPIE -g $(ATMOSPHERE_BUILD_SETTINGS)
 export ATMOSPHERE_CFLAGS   := -Wall -ffunction-sections -fdata-sections -fno-strict-aliasing -fwrapv  \
                               -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-stack-protector \
-                              -Wno-format-truncation -Wno-format-zero-length -Wno-stringop-truncation
+                              -Wno-format-zero-length
 
+ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),gcc)
+export ATMOSPHERE_CFLAGS += -Wno-stringop-truncation -Wno-format-truncation
+else ifeq ($(strip $(ATMOSPHERE_COMPILER_NAME)),clang)
+export ATMOSPHERE_CFLAGS += -Wno-c99-designator -Wno-gnu-alignof-expression -Wno-unused-private-field
+endif
 
 export ATMOSPHERE_CXXFLAGS := -fno-rtti -fno-exceptions -std=gnu++20 -Wno-invalid-offsetof
 export ATMOSPHERE_ASFLAGS  :=
@@ -39,10 +59,16 @@ export ATMOSPHERE_ARCH_NAME  := arm64
 export ATMOSPHERE_BOARD_NAME := nintendo_nx
 export ATMOSPHERE_OS_NAME    := horizon
 
-export ATMOSPHERE_SUB_ARCH_DIR  = armv8a
+export ATMOSPHERE_SUB_ARCH_DIR  := armv8a
-export ATMOSPHERE_SUB_ARCH_NAME = armv8a
+export ATMOSPHERE_SUB_ARCH_NAME := armv8a
 
 export ATMOSPHERE_CPU_EXTENSIONS := arm_crypto_extension aarch64_crypto_extension
+
+export ATMOSPHERE_BOOT_CPU := arm7tdmi
+export ATMOSPHERE_BOOT_ARCH_NAME     := arm
+export ATMOSPHERE_BOOT_BOARD_NAME    := nintendo_nx
+export ATMOSPHERE_BOOT_OS_NAME       := horizon
+export ATMOSPHERE_BOOT_SUB_ARCH_NAME := armv4t
 else ifeq ($(ATMOSPHERE_CPU),arm7tdmi)
 export ATMOSPHERE_ARCH_DIR   := arm
 export ATMOSPHERE_BOARD_DIR  := nintendo/nx_bpmp
@@ -52,12 +78,14 @@ export ATMOSPHERE_ARCH_NAME  := arm
 export ATMOSPHERE_BOARD_NAME := nintendo_nx
 export ATMOSPHERE_OS_NAME    := horizon
 
-export ATMOSPHERE_SUB_ARCH_DIR  = armv4t
+export ATMOSPHERE_SUB_ARCH_DIR  := armv4t
-export ATMOSPHERE_SUB_ARCH_NAME = armv4t
+export ATMOSPHERE_SUB_ARCH_NAME := armv4t
 
 export ATMOSPHERE_CPU_EXTENSIONS :=
 endif
 
+export ATMOSPHERE_LIBDIRS :=
+
 else ifeq ($(ATMOSPHERE_BOARD),qemu-virt)
 
 
@@ -76,6 +104,53 @@ export ATMOSPHERE_SUB_ARCH_NAME = armv8a
 export ATMOSPHERE_CPU_EXTENSIONS := arm_crypto_extension aarch64_crypto_extension
 endif
 
+export ATMOSPHERE_LIBDIRS :=
+
+else ifeq ($(ATMOSPHERE_BOARD),generic_windows)
+
+ifeq ($(ATMOSPHERE_CPU),generic_x64)
+export ATMOSPHERE_ARCH_DIR   := x64
+export ATMOSPHERE_BOARD_DIR  := generic/windows
+export ATMOSPHERE_OS_DIR     := windows
+
+export ATMOSPHERE_ARCH_NAME  := x64
+export ATMOSPHERE_BOARD_NAME := generic_windows
+export ATMOSPHERE_OS_NAME    := windows
+
+endif
+
+else ifeq ($(ATMOSPHERE_BOARD),generic_linux)
+
+ifeq ($(ATMOSPHERE_CPU),generic_x64)
+export ATMOSPHERE_ARCH_DIR   := x64
+export ATMOSPHERE_ARCH_NAME  := x64
+else ifeq ($(ATMOSPHERE_CPU),generic_arm64)
+export ATMOSPHERE_ARCH_DIR   := arm64
+export ATMOSPHERE_ARCH_NAME  := arm64
+endif
+
+export ATMOSPHERE_BOARD_DIR  := generic/linux
+export ATMOSPHERE_OS_DIR     := linux
+
+export ATMOSPHERE_BOARD_NAME := generic_linux
+export ATMOSPHERE_OS_NAME    := linux
+
+else ifeq ($(ATMOSPHERE_BOARD),generic_macos)
+
+ifeq ($(ATMOSPHERE_CPU),generic_x64)
+export ATMOSPHERE_ARCH_DIR   := x64
+export ATMOSPHERE_ARCH_NAME  := x64
+else ifeq ($(ATMOSPHERE_CPU),generic_arm64)
+export ATMOSPHERE_ARCH_DIR   := arm64
+export ATMOSPHERE_ARCH_NAME  := arm64
+endif
+
+export ATMOSPHERE_BOARD_DIR  := generic/macos
+export ATMOSPHERE_OS_DIR     := macos
+
+export ATMOSPHERE_BOARD_NAME := generic_macos
+export ATMOSPHERE_OS_NAME    := macos
+
 endif
 
 ifeq ($(ATMOSPHERE_CPU),arm-cortex-a57)
@@ -88,6 +163,15 @@ export ATMOSPHERE_CPU_DIR    := arm7tdmi
 export ATMOSPHERE_CPU_NAME   := arm7tdmi
 endif
 
+ifeq ($(ATMOSPHERE_CPU),generic_x64)
+export ATMOSPHERE_CPU_DIR    := generic_x64
+export ATMOSPHERE_CPU_NAME   := generic_x64
+endif
+
+ifeq ($(ATMOSPHERE_CPU),generic_arm64)
+export ATMOSPHERE_CPU_DIR    := generic_arm64
+export ATMOSPHERE_CPU_NAME   := generic_arm64
+endif
 
 export ATMOSPHERE_ARCH_MAKE_DIR  := $(ATMOSPHERE_CONFIG_MAKE_DIR)/arch/$(ATMOSPHERE_ARCH_DIR)
 export ATMOSPHERE_BOARD_MAKE_DIR := $(ATMOSPHERE_CONFIG_MAKE_DIR)/board/$(ATMOSPHERE_BOARD_DIR)
@@ -95,11 +179,40 @@ export ATMOSPHERE_OS_MAKE_DIR    := $(ATMOSPHERE_CONFIG_MAKE_DIR)/os/$(ATMOSPHER
 export ATMOSPHERE_CPU_MAKE_DIR   := $(ATMOSPHERE_ARCH_MAKE_DIR)/cpu/$(ATMOSPHERE_CPU_DIR)
 
 ifneq ($(strip $(ATMOSPHERE_SUB_ARCH_NAME)),)
-export ATMOSPHERE_LIBRARY_DIR := lib_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)
+export ATMOSPHERE_FULL_NAME   := $(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)_$(ATMOSPHERE_BUILD_NAME)
-export ATMOSPHERE_BUILD_DIR := build_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)
+export ATMOSPHERE_LIBRARY_DIR := lib/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BUILD_DIR   := build/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_OUT_DIR     := out/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
 else
-export ATMOSPHERE_LIBRARY_DIR := lib_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)
+export ATMOSPHERE_FULL_NAME   := $(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(ATMOSPHERE_BUILD_NAME)
-export ATMOSPHERE_BUILD_DIR := build_$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)
+export ATMOSPHERE_LIBRARY_DIR := lib/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BUILD_DIR   := build/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_OUT_DIR     := out/$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+endif
+
+ifneq ($(strip $(ATMOSPHERE_BOOT_ARCH_NAME)),)
+
+ifneq ($(strip $(ATMOSPHERE_SUB_ARCH_NAME)),)
+export ATMOSPHERE_BOOT_FULL_NAME   := $(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)_$(ATMOSPHERE_BOOT_SUB_ARCH_NAME)_$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_LIBRARY_DIR := lib/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)_$(ATMOSPHERE_BOOT_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_BUILD_DIR   := build/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)_$(ATMOSPHERE_BOOT_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_OUT_DIR     := out/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)_$(ATMOSPHERE_BOOT_SUB_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+else
+export ATMOSPHERE_BOOT_FULL_NAME   := $(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)_$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_LIBRARY_DIR := lib/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_BUILD_DIR   := build/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+export ATMOSPHERE_BOOT_OUT_DIR     := out/$(ATMOSPHERE_BOOT_BOARD_NAME)_$(ATMOSPHERE_BOOT_ARCH_NAME)/$(ATMOSPHERE_BUILD_NAME)
+endif
+
+else
+export ATMOSPHERE_BOOT_FULL_NAME   := $(ATMOSPHERE_FULL_NAME)
+export ATMOSPHERE_BOOT_LIBRARY_DIR := $(ATMOSPHERE_LIBRARY_DIR)
+export ATMOSPHERE_BOOT_BUILD_DIR   := $(ATMOSPHERE_BUILD_DIR)
+export ATMOSPHERE_BOOT_OUT_DIR     := $(ATMOSPHERE_OUT_DIR)
+endif
+
+ifeq ($(strip $(ATMOSPHERE_BOOT_CPU)),)
+export ATMOSPHERE_BOOT_CPU := $(ATMOSPHERE_CPU)
 endif
 
 include $(ATMOSPHERE_ARCH_MAKE_DIR)/arch.mk
@@ -182,15 +295,14 @@ FIND_SOURCE_FILES=$(foreach dir,$1,$(filter-out $(notdir $(wildcard $(dir)/*.arc
                   $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES,$(dir),os,$(ATMOSPHERE_OS_NAME),$2)) \
                   $(foreach dir,$1,$(call FIND_SPECIFIC_SOURCE_FILES_EX,$(dir),cpu,$(ATMOSPHERE_CPU_NAME) $(ATMOSPHERE_CPU_EXTENSIONS),$2))
 
-ATMOSPHERE_GCH_IDENTIFIER ?= ams_placeholder_gch_identifier
+ATMOSPHERE_GCH_IDENTIFIER := $(ATMOSPHERE_FULL_NAME)
 
 #---------------------------------------------------------------------------------
 # Rules for compiling pre-compiled headers
 #---------------------------------------------------------------------------------
-%.hpp.gch/$(ATMOSPHERE_GCH_IDENTIFIER): %.hpp | %.hpp.gch
+%.hpp.gch/$(ATMOSPHERE_GCH_IDENTIFIER): %.hpp %.hpp.gch
 	@echo Precompiling $(notdir $<) for $(ATMOSPHERE_GCH_IDENTIFIER)
 	$(SILENTCMD)$(CXX) -w -x c++-header -MMD -MP -MQ$@ -MF $(DEPSDIR)/$(notdir $*).d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)
 
 %.hpp.gch: %.hpp
-	@echo Precompiling $(notdir $<)
+	@[ -d $@ ] || mkdir -p $@
-	$(SILENTCMD)$(CXX) -w -x c++-header -MMD -MP -MQ$@ -MF $(DEPSDIR)/$(notdir $*).d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER)

libraries/config/os/linux/os.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_OS_LINUX
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/os/macos/os.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_OS_MACOS
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/os/windows/os.mk

@@ -0,0 +1,5 @@
+export ATMOSPHERE_DEFINES  += -DATMOSPHERE_OS_WINDOWS
+export ATMOSPHERE_SETTINGS +=
+export ATMOSPHERE_CFLAGS   +=
+export ATMOSPHERE_CXXFLAGS +=
+export ATMOSPHERE_ASFLAGS  +=

libraries/config/templates/exosphere.mk

@@ -7,8 +7,14 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../common.mk
 # options for code generation
 #---------------------------------------------------------------------------------
 ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
-DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 -Os -Wextra -Werror -fno-non-call-exceptions \
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+endif
+
+DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE -DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -mgeneral-regs-only -ffixed-x18 $(ATMOSPHERE_OPTIMIZATION_FLAG) -Wextra -Werror -fno-non-call-exceptions \
                -Wno-array-bounds \
                -Wno-stringop-overflow \
                -Wno-stringop-overread
@@ -16,8 +22,14 @@ CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
 else ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm)
-DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -Werror -fno-non-call-exceptions \
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -O2
+endif
+
+DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE -DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS
+SETTINGS    := $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -Werror -fno-non-call-exceptions \
                -Wno-array-bounds \
                -Wno-stringop-overflow \
                -Wno-stringop-overread
@@ -26,7 +38,7 @@ CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
 endif
 
-export LDFLAGS	=	-specs=$(TOPDIR)/$(notdir $(TOPDIR)).specs -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-exceptions -fno-rtti -fno-use-cxa-atexit -nostdlib -nostartfiles -g $(CXXFLAGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
+export LDFLAGS	=	-specs=$(ATMOSPHERE_TOPDIR)/$(notdir $(ATMOSPHERE_TOPDIR)).specs -fno-asynchronous-unwind-tables -fno-unwind-tables -fno-exceptions -fno-rtti -fno-use-cxa-atexit -nostdlib -nostartfiles -g $(CXXFLAGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
 
 export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,__cxa_throw \
@@ -43,7 +55,7 @@ export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,_ZSt20__throw_length_errorPKc \
 			-Wl,--wrap,_ZNSt11logic_errorC2EPKc
 
-export LIBS := -l$(LIBEXOSPHERE_NAME) -lgcc
+export LIBS := -lexosphere -lgcc
 
 #---------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level containing

libraries/config/templates/mesosphere.mk

@@ -6,13 +6,19 @@ include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../common.mk
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+endif
+
 export DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
-export SETTINGS    := $(ATMOSPHERE_SETTINGS) -Os -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
+export SETTINGS    := $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
 export CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 export CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 export ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 
-export LDFLAGS	=	-specs=$(TOPDIR)/$(notdir $(TOPDIR)).specs -fno-asynchronous-unwind-tables -fno-unwind-tables -nostdlib -nostartfiles -g $(CXXFLAGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
+export LDFLAGS	=	-specs=$(ATMOSPHERE_TOPDIR)/$(notdir $(ATMOSPHERE_TOPDIR)).specs -fno-asynchronous-unwind-tables -fno-unwind-tables -nostdlib -nostartfiles -g $(CXXFLAGS) -Wl,-Map,$(notdir $*.map) -Wl,-z,relro,-z,now
 
 export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,__cxa_throw \
@@ -29,7 +35,7 @@ export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,_ZSt20__throw_length_errorPKc \
 			-Wl,--wrap,_ZNSt11logic_errorC2EPKc
 
-export LIBS := -l$(LIBMESOSPHERE_NAME)
+export LIBS := -lmesosphere
 
 #---------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level containing

libraries/config/templates/stratosphere.mk

@@ -3,6 +3,8 @@
 #---------------------------------------------------------------------------------
 include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../common.mk
 
+ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
+
 #---------------------------------------------------------------------------------
 # pull in switch rules
 #---------------------------------------------------------------------------------
@@ -12,15 +14,24 @@ endif
 
 include $(DEVKITPRO)/libnx/switch_rules
 
+endif
+
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -O2
+endif
+
 export DEFINES     = $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_STRATOSPHERE -D_GNU_SOURCE
-export SETTINGS    = $(ATMOSPHERE_SETTINGS) -O2 -Wextra -Werror -Wno-missing-field-initializers
+export SETTINGS    = $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -Wextra -Werror -Wno-missing-field-initializers
 export CFLAGS      = $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 export CXXFLAGS    = $(CFLAGS) $(ATMOSPHERE_CXXFLAGS)
 export ASFLAGS     = $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES)
 
+ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
 export CXXREQUIRED := -Wl,--require-defined,__libnx_initheap \
                       -Wl,--require-defined,__libnx_exception_handler \
                       -Wl,--require-defined,__libnx_alloc \
@@ -45,16 +56,50 @@ export CXXWRAPS := -Wl,--wrap,__cxa_pure_virtual \
 			-Wl,--wrap,_ZSt20__throw_length_errorPKc \
 			-Wl,--wrap,_ZNSt11logic_errorC2EPKc \
 			-Wl,--wrap,exit
+else ifeq ($(ATMOSPHERE_BOARD),generic_windows)
+export CXXREQUIRED :=
+export CXXWRAPS    := -Wl,--wrap,__p__acmdln
+else
+export CXXREQUIRED :=
+export CXXWRAPS    :=
+endif
 
+
+ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
 export LDFLAGS     = -specs=$(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere/stratosphere.specs -specs=$(DEVKITPRO)/libnx/switch.specs $(CXXFLAGS) $(CXXWRAPS) $(CXXREQUIRED) -Wl,-Map,$(notdir $*.map)
+else ifeq ($(ATMOSPHERE_BOARD),generic_macos)
+export LDFLAGS     = $(CXXFLAGS) $(CXXWRAPS) $(CXXREQUIRED) -Wl,-map,$(notdir $@.map)
+else
+export LDFLAGS     = $(CXXFLAGS) $(CXXWRAPS) $(CXXREQUIRED) -Wl,-Map,$(notdir $*.map)
+endif
 
-export LIBS	= -lstratosphere -lnx
+ifeq ($(ATMOSPHERE_COMPILER_NAME),clang)
+export LDFLAGS += -fuse-ld=lld
+endif
+
+ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
+export LIBS	:= -lstratosphere -lnx
+else ifeq ($(ATMOSPHERE_BOARD),generic_windows)
+export LIBS	:= -lstratosphere -lwinmm -lws2_32
+else ifeq ($(ATMOSPHERE_BOARD),generic_linux)
+export LIBS := -lstratosphere -pthread
+else ifeq ($(ATMOSPHERE_BOARD),generic_macos)
+export LIBS := -lstratosphere -pthread
+else
+export LIBS := -lstratosphere
+endif
 
 #---------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level containing
 # include and lib
 #---------------------------------------------------------------------------------
-export LIBDIRS	= $(PORTLIBS) $(LIBNX) $(ATMOSPHERE_LIBRARIES_DIR)/libvapours $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere
+ifeq ($(ATMOSPHERE_BOARD),nx-hac-001)
+export LIBDIRS	= $(PORTLIBS) $(LIBNX)
+else
+export LIBDIRS	=
+endif
+
+export AMS_LIBDIRS = $(ATMOSPHERE_LIBRARIES_DIR)/libvapours $(ATMOSPHERE_LIBRARIES_DIR)/libstratosphere
 
 #---------------------------------------------------------------------------------
 # stratosphere sysmodules may (but usually do not) have an exefs source dir

libraries/libexosphere/Makefile

@@ -1,34 +1,42 @@
 ATMOSPHERE_BUILD_CONFIGS :=
-all: arm64-release arm-release
+all: nx_release
+
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-arm64-$(strip $1):
+$(strip $1):
-	@$$(MAKE) -f arm64.mk $(strip $1)
+	@echo "Building $(strip $1)"
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libexosphere.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
 
-arm-$(strip $1):
+clean-$(strip $1):
-	@$$(MAKE) -f arm.mk $(strip $1)
+	@echo "Cleaning $(strip $1)"
-
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libexosphere.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-clean-arm64-$(strip $1):
-	@$$(MAKE) -f arm64.mk clean-$(strip $1)
-
-clean-arm-$(strip $1):
-	@$$(MAKE) -f arm.mk clean-$(strip $1)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release))
+define ATMOSPHERE_ADD_TARGETS
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug))
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit))
 
-clean-arm64:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
-	@$(MAKE) -f arm64.mk clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
+))
 
-clean-arm:
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	@$(MAKE) -f arm.mk clean
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
+))
 
-clean: clean-arm64 clean-arm
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
+))
 
-.PHONY: all clean clean-arm64 clean-arm $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),arm64-$(config) arm-$(config) clean-arm64-$(config) clean-arm-$(config))
+endef
+
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx_bpmp, nx-hac-001, arm7tdmi,))
+
+clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
+
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))

libraries/libexosphere/libexosphere.mk

@@ -1,25 +1,42 @@
-#---------------------------------------------------------------------------------
-# Define the atmosphere board and cpu
-#---------------------------------------------------------------------------------
-export ATMOSPHERE_BOARD := nx-hac-001
-export ATMOSPHERE_CPU   := arm7tdmi
-
 #---------------------------------------------------------------------------------
 # pull in common atmosphere configuration
 #---------------------------------------------------------------------------------
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
+include $(CURRENT_DIRECTORY)/../config/common.mk
 
 #---------------------------------------------------------------------------------
 # options for code generation
 #---------------------------------------------------------------------------------
+PRECOMPILED_HEADERS :=
+
+ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
+
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+endif
+
+else
+
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -O2
+endif
+
+endif
+
+DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE -DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS
+SETTINGS    := $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -Wextra -Werror -fno-non-call-exceptions -Wno-array-bounds -Wno-stringop-overflow -Wno-stringop-overread
+
+ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm64)
+SETTINGS    += -mgeneral-regs-only -ffixed-x18
+else ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm)
+SETTINGS    += -flto
+endif
 
-DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_EXOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -Wextra -Werror -flto -fno-non-call-exceptions \
-               -Wno-array-bounds \
-               -Wno-stringop-overflow \
-               -Wno-stringop-overread
 CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
 CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit
 ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
@@ -74,65 +91,24 @@ export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
 
 #---------------------------------------------------------------------------------
 
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
-
-define ATMOSPHERE_ADD_TARGET
-
-ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
-
-$(strip $1): $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
-
-$$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2) : $$(ATMOSPHERE_LIBRARY_DIR) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(SOURCES) $$(INCLUDES) $$(GCH_DIRS)
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(CURDIR)/$$@ $(3) \
-	ATMOSPHERE_GCH_IDENTIFIER="$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1)" \
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
-
-clean-$(strip $1):
-	@echo clean $(strip $1) ...
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
-	@rm -fr $$(foreach hdr,$$(GCH_DIRS),$$(hdr)/$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1))
-	@for i in $$(GCH_DIRS) $$(ATMOSPHERE_BUILD_DIR) $$(ATMOSPHERE_LIBRARY_DIR); do [ -d $$$$i ] && rmdir --ignore-fail-on-non-empty $$$$i || true; done
-
-.PHONY: $(strip $1) clean-$(strip $1) $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
-
-endef
-
-$(eval $(call ATMOSPHERE_ADD_TARGET, release, $(TARGET).a, \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS " \
-))
-
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, $(TARGET)_debug.a, \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_DEBUGGING" \
-))
-
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, $(TARGET)_audit.a, \
-	ATMOSPHERE_BUILD_SETTINGS="-DAMS_FORCE_DISABLE_DETAILED_ASSERTIONS -DAMS_BUILD_FOR_AUDITING" \
-))
-
-#---------------------------------------------------------------------------------
-
--include $(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME).mk
-
-ALL_GCH_IDENTIFIERS := $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(config))
-ALL_GCH_FILES       := $(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(foreach id,$(ALL_GCH_IDENTIFIERS),$(hdr)/$(id)))
-
 .PHONY: clean all
 
-$(ATMOSPHERE_LIBRARY_DIR) $(GCH_DIRS):
+all: $(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(SOURCES) $(INCLUDES) $(GCH_DIRS) $(CPPFILES) $(CFILES) $(SFILES)
-	@[ -d $@ ] || mkdir -p $@
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURDIR)/$(ATMOSPHERE_LIBRARY_DIR)/$(TARGET).a \
-
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
-$(ATMOSPHERE_BUILD_DIR)/%:
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
-	@[ -d $@ ] || mkdir -p $@
+	-f $(THIS_MAKEFILE)
 
 #---------------------------------------------------------------------------------
 clean:
-	@echo clean ...
+	@echo clean $(ATMOSPHERE_BUILD_NAME) ...
-	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARY_DIR) *.bz2 $(ALL_GCH_FILES)
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+	@rm -fr $(foreach hdr,$(GCH_DIRS),$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
 	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
 
+$(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(GCH_DIRS):
+	@[ -d $@ ] || mkdir -p $@
+
 #---------------------------------------------------------------------------------
 else
 
@@ -148,8 +124,12 @@ $(OFILES)	:	$(GCH_FILES)
 
 $(OFILES_SRC)	: $(HFILES_BIN)
 
-libc.o: CFLAGS += -fno-builtin -fno-lto
+libc.o: CFLAGS += -fno-builtin
-util_api.o: CXXFLAGS += -fno-lto
+
+ifeq ($(strip $(ATMOSPHERE_ARCH_NAME)),arm)
+libc.o: CFLAGS += -fno-lto
+util_api.o: CFLAGS += -fno-lto
+endif
 
 #---------------------------------------------------------------------------------
 %_bin.h %.bin.o	:	%.bin
@@ -163,3 +143,4 @@ util_api.o: CXXFLAGS += -fno-lto
 #---------------------------------------------------------------------------------------
 endif
 #---------------------------------------------------------------------------------------
+

libraries/libmesosphere/Makefile

@@ -1,169 +1,42 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# pull in common atmosphere configuration
+all: nx_release
-#---------------------------------------------------------------------------------
+
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include $(CURRENT_DIRECTORY)/../config/common.mk
-
-#---------------------------------------------------------------------------------
-# options for code generation
-#---------------------------------------------------------------------------------
-PRECOMPILED_HEADERS := include/mesosphere.hpp
-
-DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -Os -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
-CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
-CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit -flto
-ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
-
-SOURCES     += $(foreach v,$(call ALL_SOURCE_DIRS,../libvapours/source),$(if $(findstring ../libvapours/source/sdmmc,$v),,$v))
-
-LIBS        :=
-
-#---------------------------------------------------------------------------------
-# list of directories containing libraries, this must be the top level containing
-# include and lib
-#---------------------------------------------------------------------------------
-LIBDIRS	:= $(ATMOSPHERE_LIBRARIES_DIR)/libvapours
-
-#---------------------------------------------------------------------------------
-# no real need to edit anything past this point unless you need to add additional
-# rules for different file extensions
-#---------------------------------------------------------------------------------
-ifneq ($(__RECURSIVE__),1)
-#---------------------------------------------------------------------------------
-
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
-
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
-
-#---------------------------------------------------------------------------------
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
-
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
-export GCH_DIRS     :=  $(PRECOMPILED_HEADERS:.hpp=.hpp.gch)
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
-
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-			-I.
-
-#---------------------------------------------------------------------------------
-
-ATMOSPHERE_BUILD_CONFIGS :=
-all: release
 
 define ATMOSPHERE_ADD_TARGET
 
 ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-$(strip $1): $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
+$(strip $1):
-
+	@echo "Building $(strip $1)"
-$$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2) : $$(ATMOSPHERE_LIBRARY_DIR) $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(SOURCES) $$(INCLUDES) $$(GCH_DIRS)
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libmesosphere.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	@$$(MAKE) __RECURSIVE__=1 OUTPUT=$$(CURDIR)/$$@ $(3) \
-	ATMOSPHERE_GCH_IDENTIFIER="$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1)" \
-	DEPSDIR=$$(CURDIR)/$$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	--no-print-directory -C $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) \
-	-f $$(THIS_MAKEFILE)
 
 clean-$(strip $1):
-	@echo clean $(strip $1) ...
+	@echo "Cleaning $(strip $1)"
-	@rm -fr $$(ATMOSPHERE_BUILD_DIR)/$(strip $1) $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libmesosphere.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-	@rm -fr $$(foreach hdr,$$(GCH_DIRS),$$(hdr)/$$(ATMOSPHERE_BOARD_NAME)_$$(ATMOSPHERE_ARCH_NAME)_$(strip $1))
-	@for i in $$(GCH_DIRS) $$(ATMOSPHERE_BUILD_DIR) $$(ATMOSPHERE_LIBRARY_DIR); do [ -d $$$$i ] && rmdir --ignore-fail-on-non-empty $$$$i || true; done
-
-.PHONY: $(strip $1) clean-$(strip $1) $$(ATMOSPHERE_LIBRARY_DIR)/$(strip $2)
 
 endef
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, release, $(TARGET).a, \
+define ATMOSPHERE_ADD_TARGETS
-	ATMOSPHERE_BUILD_SETTINGS="" \
+
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, release, $(strip $2), $(strip $3), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4)" \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, debug, $(TARGET)_debug.a, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, debug, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_DEBUGGING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, audit, $(TARGET)_audit.a, \
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, audit, $(strip $2), $(strip $3), \
-	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_AUDITING" \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $4) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 \
 ))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, qemu_virt_release, $(TARGET)_qemu_virt.a, \
+endef
-	ATMOSPHERE_BUILD_SETTINGS="" \
-))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, qemu_virt_debug, $(TARGET)_qemu_virt_debug.a, \
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx, nx-hac-001, arm-cortex-a57,))
-	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_DEBUGGING" \
+$(eval $(call ATMOSPHERE_ADD_TARGETS, qemu_virt_a57, qemu-virt, arm-cortex-a57,))
-))
 
-$(eval $(call ATMOSPHERE_ADD_TARGET, qemu_virt_audit, $(TARGET)_qemu_virt_audit.a, \
+clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
-	ATMOSPHERE_BUILD_SETTINGS="-DMESOSPHERE_BUILD_FOR_AUDITING" \
-))
-
-#---------------------------------------------------------------------------------
-
--include $(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME).mk
-
-ALL_GCH_IDENTIFIERS := $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),$(ATMOSPHERE_BOARD_NAME)_$(ATMOSPHERE_ARCH_NAME)_$(config))
-ALL_GCH_FILES       := $(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(foreach id,$(ALL_GCH_IDENTIFIERS),$(hdr)/$(id)))
-
-.PHONY: clean all
-
-$(ATMOSPHERE_LIBRARY_DIR) $(GCH_DIRS):
-	@[ -d $@ ] || mkdir -p $@
-
-$(ATMOSPHERE_BUILD_DIR)/%:
-	@[ -d $@ ] || mkdir -p $@
-
-#---------------------------------------------------------------------------------
-clean:
-	@echo clean ...
-	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_LIBRARY_DIR) *.bz2 $(ALL_GCH_FILES)
-	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
-
-#---------------------------------------------------------------------------------
-else
-
-GCH_FILES :=	$(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(CURRENT_DIRECTORY)/$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
-DEPENDS	:=	$(OFILES:.o=.d) $(foreach hdr,$(GCH_FILES),$(notdir $(patsubst %.hpp.gch/,%.d,$(dir $(hdr)))))
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-$(OUTPUT)	:	$(OFILES)
-
-$(filter-out kern_svc_tables.o, $(OFILES))	:	$(GCH_FILES)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-kern_libc_generic.o: CFLAGS += -fno-builtin
-
-#---------------------------------------------------------------------------------
-%_bin.h %.bin.o	:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------
 
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))

libraries/libmesosphere/include/mesosphere/kern_panic.hpp

@@ -24,6 +24,19 @@ namespace ams::kern {
 
 }
 
+namespace ams::diag {
+
+    NORETURN ALWAYS_INLINE void AssertionFailureImpl(const char *file, int line, const char *func, const char *expr, u64 value) {
+        #if defined(MESOSPHERE_ENABLE_DEBUG_PRINT)
+        ::ams::kern::Panic(file, line, "ams::diag::AssertionFailureImpl: %s:%s 0x%016" PRIx64 "", func, expr, value);
+        #else
+        ::ams::kern::Panic();
+        AMS_UNUSED(file, line, func, expr, value);
+        #endif
+    }
+
+}
+
 #define MESOSPHERE_UNUSED(...) AMS_UNUSED(__VA_ARGS__)
 
 #ifdef MESOSPHERE_ENABLE_DEBUG_PRINT

libraries/libmesosphere/libmesosphere.mk

@@ -0,0 +1,123 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
+CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
+include $(CURRENT_DIRECTORY)/../config/common.mk
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+PRECOMPILED_HEADERS :=  include/mesosphere.hpp
+#PRECOMPILED_HEADERS :=
+
+ifeq ($(ATMOSPHERE_BUILD_FOR_DEBUGGING),1)
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+else
+ATMOSPHERE_OPTIMIZATION_FLAG := -Os
+endif
+
+DEFINES	    := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
+SETTINGS    := $(ATMOSPHERE_SETTINGS) $(ATMOSPHERE_OPTIMIZATION_FLAG) -mgeneral-regs-only -ffixed-x18 -Wextra -Werror -fno-non-call-exceptions
+CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
+CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -fno-use-cxa-atexit -flto
+ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
+
+SOURCES     += $(foreach v,$(call ALL_SOURCE_DIRS,../libvapours/source),$(if $(findstring ../libvapours/source/sdmmc,$v),,$v))
+
+LIBS        :=
+
+#---------------------------------------------------------------------------------
+# list of directories containing libraries, this must be the top level containing
+# include and lib
+#---------------------------------------------------------------------------------
+LIBDIRS	:= $(ATMOSPHERE_LIBRARIES_DIR)/libvapours
+
+#---------------------------------------------------------------------------------
+# no real need to edit anything past this point unless you need to add additional
+# rules for different file extensions
+#---------------------------------------------------------------------------------
+ifneq ($(__RECURSIVE__),1)
+#---------------------------------------------------------------------------------
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
+SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
+
+#---------------------------------------------------------------------------------
+# use CXX for linking C++ projects, CC for standard C
+#---------------------------------------------------------------------------------
+ifeq ($(strip $(CPPFILES)),)
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CC)
+#---------------------------------------------------------------------------------
+else
+#---------------------------------------------------------------------------------
+	export LD	:=	$(CXX)
+#---------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------
+
+export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+export GCH_DIRS     :=  $(PRECOMPILED_HEADERS:.hpp=.hpp.gch)
+export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+#---------------------------------------------------------------------------------
+
+.PHONY: clean all
+
+all: $(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(SOURCES) $(INCLUDES) $(GCH_DIRS) $(CPPFILES) $(CFILES) $(SFILES)
+	@$(MAKE) __RECURSIVE__=1 OUTPUT=$(CURDIR)/$(ATMOSPHERE_LIBRARY_DIR)/$(TARGET).a \
+	DEPSDIR=$(CURDIR)/$(ATMOSPHERE_BUILD_DIR) \
+	--no-print-directory -C $(ATMOSPHERE_BUILD_DIR) \
+	-f $(THIS_MAKEFILE)
+
+#---------------------------------------------------------------------------------
+clean:
+	@echo clean $(ATMOSPHERE_BUILD_NAME) ...
+	@rm -fr $(ATMOSPHERE_BUILD_DIR) $(ATMOSPHERE_OUT_DIR)
+	@rm -fr $(foreach hdr,$(GCH_DIRS),$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
+	@for i in $(GCH_DIRS); do [ -d $$i ] && rmdir --ignore-fail-on-non-empty $$i || true; done
+
+$(ATMOSPHERE_LIBRARY_DIR) $(ATMOSPHERE_BUILD_DIR) $(GCH_DIRS):
+	@[ -d $@ ] || mkdir -p $@
+
+#---------------------------------------------------------------------------------
+else
+
+GCH_FILES := $(foreach hdr,$(PRECOMPILED_HEADERS:.hpp=.hpp.gch),$(CURRENT_DIRECTORY)/$(hdr)/$(ATMOSPHERE_GCH_IDENTIFIER))
+DEPENDS	:=	$(OFILES:.o=.d) $(foreach hdr,$(GCH_FILES),$(notdir $(patsubst %.hpp.gch/,%.d,$(dir $(hdr)))))
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT)	:	$(OFILES)
+
+$(filter-out kern_svc_tables.o, $(OFILES))	:	$(GCH_FILES)
+
+$(OFILES_SRC)	: $(HFILES_BIN)
+
+kern_libc_generic.o: CFLAGS += -fno-builtin
+
+#---------------------------------------------------------------------------------
+%_bin.h %.bin.o	:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
+

libraries/libstratosphere/Makefile

@@ -1,145 +1,50 @@
-#---------------------------------------------------------------------------------
+ATMOSPHERE_BUILD_CONFIGS :=
-# pull in common atmosphere configuration
+all: nx_release
-#---------------------------------------------------------------------------------
+
 THIS_MAKEFILE     := $(abspath $(lastword $(MAKEFILE_LIST)))
 CURRENT_DIRECTORY := $(abspath $(dir $(THIS_MAKEFILE)))
-include $(CURRENT_DIRECTORY)/../config/common.mk
 
-#---------------------------------------------------------------------------------
+define ATMOSPHERE_ADD_TARGET
-# pull in switch rules
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(DEVKITPRO)),)
-$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
-endif
 
-include $(DEVKITPRO)/libnx/switch_rules
+ATMOSPHERE_BUILD_CONFIGS += $(strip $1)
 
-#---------------------------------------------------------------------------------
+$(strip $1):
-# options for code generation
+	@echo "Building $(strip $1)"
-#---------------------------------------------------------------------------------
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libstratosphere.mk ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-PRECOMPILED_HEADERS := $(CURRENT_DIRECTORY)/include/stratosphere.hpp
-#PRECOMPILED_HEADERS :=
 
-DEFINES	    := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_STRATOSPHERE -D_GNU_SOURCE
+clean-$(strip $1):
-SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -Wextra -Werror -Wno-missing-field-initializers -flto
+	@echo "Cleaning $(strip $1)"
-CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
+	@$$(MAKE) -f $(CURRENT_DIRECTORY)/libstratosphere.mk clean ATMOSPHERE_MAKEFILE_TARGET="$(strip $1)" ATMOSPHERE_BUILD_NAME="$(strip $2)" ATMOSPHERE_BOARD="$(strip $3)" ATMOSPHERE_CPU="$(strip $4)" $(strip $5)
-CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS)
-ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
 
-LDFLAGS     := -specs=$(DEVKITPRO)/libnx/switch.specs $(SETTINGS) -Wl,-Map,$(notdir $*.map)
+endef
 
-SOURCES     += $(call ALL_SOURCE_DIRS,../libvapours/source)
+define ATMOSPHERE_ADD_TARGETS
-SOURCES     += $(call UNFILTERED_SOURCE_DIRS,source/os)
 
-LIBS        := -lnx
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_release, $(strip $2)release, $(strip $3), $(strip $4), \
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $5)" $(strip $6) \
+))
 
-#---------------------------------------------------------------------------------
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_debug, $(strip $2)debug, $(strip $3), $(strip $4), \
-# list of directories containing libraries, this must be the top level containing
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $5) -DAMS_BUILD_FOR_DEBUGGING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 $(strip $6) \
-# include and lib
+))
-#---------------------------------------------------------------------------------
-LIBDIRS	:= $(PORTLIBS) $(LIBNX) $(ATMOSPHERE_LIBRARIES_DIR)/libvapours
 
-#---------------------------------------------------------------------------------
+$(eval $(call ATMOSPHERE_ADD_TARGET, $(strip $1)_audit, $(strip $2)audit, $(strip $3), $(strip $4), \
-# no real need to edit anything past this point unless you need to add additional
+    ATMOSPHERE_BUILD_SETTINGS="$(strip $5) -DAMS_BUILD_FOR_AUDITING" ATMOSPHERE_BUILD_FOR_DEBUGGING=1 ATMOSPHERE_BUILD_FOR_AUDITING=1 $(strip $6) \
-# rules for different file extensions
+))
-#---------------------------------------------------------------------------------
-ifneq ($(BUILD),$(notdir $(CURDIR)))
-#---------------------------------------------------------------------------------
 
-export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) $(CURDIR)/include \
+endef
-			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
 
-CFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),c)
+$(eval $(call ATMOSPHERE_ADD_TARGETS, nx,                      , nx-hac-001, arm-cortex-a57,,))
-CPPFILES    :=	$(call FIND_SOURCE_FILES,$(SOURCES),cpp)
-SFILES      :=	$(call FIND_SOURCE_FILES,$(SOURCES),s)
 
-#---------------------------------------------------------------------------------
+$(eval $(call ATMOSPHERE_ADD_TARGETS, win_x64,                 , generic_windows, generic_x64,,))
-# use CXX for linking C++ projects, CC for standard C
-#---------------------------------------------------------------------------------
-ifeq ($(strip $(CPPFILES)),)
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CC)
-#---------------------------------------------------------------------------------
-else
-#---------------------------------------------------------------------------------
-	export LD	:=	$(CXX)
-#---------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------
 
-export OFILES_BIN	:=	$(addsuffix .o,$(BINFILES))
+$(eval $(call ATMOSPHERE_ADD_TARGETS, linux_x64,               , generic_linux, generic_x64,,))
-export OFILES_SRC	:=	$(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
+$(eval $(call ATMOSPHERE_ADD_TARGETS, linux_x64_clang,   clang_, generic_linux, generic_x64,, ATMOSPHERE_COMPILER_NAME="clang"))
-export GCH_FILES    :=	$(PRECOMPILED_HEADERS:.hpp=.hpp.gch)
+$(eval $(call ATMOSPHERE_ADD_TARGETS, linux_arm64_clang, clang_, generic_linux, generic_arm64,, ATMOSPHERE_COMPILER_NAME="clang"))
-export OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
-export HFILES_BIN	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
 
-export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+$(eval $(call ATMOSPHERE_ADD_TARGETS, macos_x64,               , generic_macos, generic_x64,,))
-			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+$(eval $(call ATMOSPHERE_ADD_TARGETS, macos_arm64,             , generic_macos, generic_arm64,,))
-			-I.
 
-.PHONY: clean all lib/$(TARGET).a
+clean: $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS),clean-$(config))
-
-#---------------------------------------------------------------------------------
-all: lib/$(TARGET).a
-
-lib:
-	@[ -d $@ ] || mkdir -p $@
-
-release:
-	@[ -d $@ ] || mkdir -p $@
-
-lib/$(TARGET).a : lib release $(SOURCES) $(INCLUDES)
-	@$(MAKE) BUILD=release OUTPUT=$(CURDIR)/$@ \
-	BUILD_CFLAGS="-DNDEBUG=1 -O2" \
-	DEPSDIR=$(CURDIR)/release \
-	--no-print-directory -C release \
-	-f $(CURDIR)/Makefile
-
-dist-bin: all
-	@tar --exclude=*~ -cjf $(TARGET).tar.bz2 include lib
-
-dist-src:
-	@tar --exclude=*~ -cjf $(TARGET)-src.tar.bz2 include source Makefile
-
-dist: dist-src dist-bin
-
-#---------------------------------------------------------------------------------
-clean:
-	@echo clean ...
-	@rm -fr release lib *.bz2 $(GCH_FILES)
-
-#---------------------------------------------------------------------------------
-else
-
-DEPENDS	:=	$(OFILES:.o=.d) $(foreach hdr,$(GCH_FILES:.hpp.gch=.d),$(notdir $(hdr)))
-
-#---------------------------------------------------------------------------------
-# main targets
-#---------------------------------------------------------------------------------
-$(OUTPUT)	:	$(OFILES)
-
-$(OFILES)	:	$(GCH_FILES)
-
-$(OFILES_SRC)	: $(HFILES_BIN)
-
-ams_environment_weak.o: CXXFLAGS += -fno-lto
-hos_version_api_weak_for_unit_test.o: CXXFLAGS += -fno-lto
-pm_info_api_weak.o: CXXFLAGS += -fno-lto
-hos_stratosphere_api.o: CXXFLAGS += -fno-lto
-
-init_operator_new.o: CXXFLAGS += -fno-lto
-init_libnx_shim.os.horizon.o: CXXFLAGS += -fno-lto
-
-#---------------------------------------------------------------------------------
-%_bin.h %.bin.o	:	%.bin
-#---------------------------------------------------------------------------------
-	@echo $(notdir $<)
-	@$(bin2o)
-
-
--include $(DEPENDS)
-
-#---------------------------------------------------------------------------------------
-endif
-#---------------------------------------------------------------------------------------
 
+.PHONY: all clean $(foreach config,$(ATMOSPHERE_BUILD_CONFIGS), $(config) clean-$(config))

libraries/libstratosphere/include/stratosphere.hpp

@@ -16,9 +16,18 @@
 
 #pragma once
 
+/* Ensure that on windows we use lean-windows headers. */
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
 /* libvapours (pulls in util, svc, results). */
 #include <vapours.hpp>
 
+#if defined(ATMOSPHERE_OS_WINDOWS)
+#include <stratosphere/windows.hpp>
+#endif
+
 /* Libstratosphere diagnostics. */
 #include <stratosphere/diag.hpp>
 

libraries/libstratosphere/include/stratosphere/ams/ams_environment.hpp

@@ -20,7 +20,9 @@
 namespace ams {
 
     /* Will be called by libstratosphere on crash. */
+    #if defined(ATMOSPHERE_OS_HORIZON)
     void CrashHandler(ThreadExceptionDump *ctx);
+    #endif
 
     /* API for boot sysmodule. */
     void InitializeForBoot();

libraries/libstratosphere/include/stratosphere/ams/ams_exosphere_api.hpp

@@ -21,6 +21,7 @@ namespace ams::exosphere {
 
     ApiInfo GetApiInfo();
 
+    #if defined(ATMOSPHERE_BOARD_NINTENDO_NX)
     void ForceRebootToRcm();
     void ForceRebootToIramPayload();
     void ForceRebootToFatalError();
@@ -35,6 +36,7 @@ namespace ams::exosphere {
 
     void CopyToIram(uintptr_t iram_dst, const void *dram_src, size_t size);
     void CopyFromIram(void *dram_dst, uintptr_t iram_src, size_t size);
+    #endif
 
 }
 

libraries/libstratosphere/include/stratosphere/capsrv/capsrv_screen_shot_decode_option.hpp

@@ -40,7 +40,10 @@ namespace ams::capsrv {
         }
     };
     static_assert(sizeof(ScreenShotDecodeOption) == 0x20);
-    static_assert(sizeof(ScreenShotDecodeOption) == sizeof(::CapsScreenShotDecodeOption));
     static_assert(util::is_pod<ScreenShotDecodeOption>::value);
 
+    #if defined(ATMOSPHERE_OS_HORIZON)
+    static_assert(sizeof(ScreenShotDecodeOption) == sizeof(::CapsScreenShotDecodeOption));
+    #endif
+
 }

libraries/libstratosphere/include/stratosphere/cfg/cfg_types.hpp

@@ -30,10 +30,12 @@ namespace ams::cfg {
             OverrideStatusFlag_AddressSpaceShift = 3,
             OverrideStatusFlag_AddressSpaceMask  = ((1u << 2) - 1) << OverrideStatusFlag_AddressSpaceShift,
 
+            #if defined(ATMOSPHERE_OS_HORIZON)
             OverrideStatusFlag_AddressSpace32Bit             = (svc::CreateProcessFlag_AddressSpace32Bit             >> svc::CreateProcessFlag_AddressSpaceShift) << OverrideStatusFlag_AddressSpaceShift,
             OverrideStatusFlag_AddressSpace64BitDeprecated   = (svc::CreateProcessFlag_AddressSpace64BitDeprecated   >> svc::CreateProcessFlag_AddressSpaceShift) << OverrideStatusFlag_AddressSpaceShift,
             OverrideStatusFlag_AddressSpace32BitWithoutAlias = (svc::CreateProcessFlag_AddressSpace32BitWithoutAlias >> svc::CreateProcessFlag_AddressSpaceShift) << OverrideStatusFlag_AddressSpaceShift,
             OverrideStatusFlag_AddressSpace64Bit             = (svc::CreateProcessFlag_AddressSpace64Bit             >> svc::CreateProcessFlag_AddressSpaceShift) << OverrideStatusFlag_AddressSpaceShift,
+            #endif
         };
 
     }
@@ -63,8 +65,12 @@ namespace ams::cfg {
     static_assert(util::is_pod<OverrideStatus>::value, "util::is_pod<OverrideStatus>::value");
 
     constexpr inline bool operator==(const OverrideStatus &lhs, const OverrideStatus &rhs) {
+        if (std::is_constant_evaluated()) {
+            return lhs.keys_held == rhs.keys_held && lhs.flags == rhs.flags;
+        } else {
             return std::memcmp(std::addressof(lhs), std::addressof(rhs), sizeof(lhs)) == 0;
         }
+    }
 
     constexpr inline bool operator!=(const OverrideStatus &lhs, const OverrideStatus &rhs) {
         return !(lhs == rhs);

libraries/libstratosphere/include/stratosphere/dd/dd_device_address_space_common.hpp

@@ -19,8 +19,12 @@
 
 namespace ams::dd {
 
+    #if defined(ATMOSPHERE_OS_HORIZON)
     using DeviceName = ::ams::svc::DeviceName;
     using enum ::ams::svc::DeviceName;
+    #else
+    enum DeviceName { };
+    #endif
 
     constexpr inline u64 DeviceAddressSpaceMemoryRegionAlignment = 4_KB;
 

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_device.hpp

@@ -81,7 +81,7 @@ namespace ams::ddsf {
                 m_session_list.clear();
             }
         protected:
-            ~IDevice() {
+            virtual ~IDevice() {
                 m_session_list.clear();
             }
         public:

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_driver.hpp

@@ -40,7 +40,7 @@ namespace ams::ddsf {
                 m_device_list.clear();
             }
         protected:
-            ~IDriver() {
+            virtual ~IDriver() {
                 m_device_list.clear();
             }
         public:

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_event_handler.hpp

@@ -53,7 +53,7 @@ namespace ams::ddsf {
         public:
             IEventHandler() : m_holder(), m_user_data(0), m_is_initialized(false), m_is_registered(false) { /* ... */ }
 
-            ~IEventHandler() {
+            virtual ~IEventHandler() {
                 if (this->IsRegistered()) {
                     this->Unlink();
                 }

libraries/libstratosphere/include/stratosphere/ddsf/ddsf_i_session.hpp

@@ -58,7 +58,7 @@ namespace ams::ddsf {
         public:
             ISession() : m_list_node(), m_device(nullptr), m_access_mode() { /* ... */ }
         protected:
-            ~ISession() { this->DetachDevice(); AMS_ASSERT(!this->IsOpen()); }
+            virtual ~ISession() { this->DetachDevice(); AMS_ASSERT(!this->IsOpen()); }
         public:
             void AddTo(List &list) {
                 list.push_back(*this);

libraries/libstratosphere/include/stratosphere/ddsf/impl/ddsf_type_tag.hpp

@@ -42,13 +42,13 @@ namespace ams::ddsf::impl {
         public:
             #if !(defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING))
                 constexpr TypeTag() : m_class_name(nullptr), m_base(nullptr) { /* ... */}
-                constexpr TypeTag(const TypeTag &b) : m_class_name(nullptr), m_base(std::addressof(b)) { AMS_ASSERT(this != m_base); }
+                constexpr TypeTag(const TypeTag &b) : m_class_name(nullptr), m_base(std::addressof(b)) { if (!std::is_constant_evaluated()) { AMS_ASSERT(this != m_base); } }
 
                 constexpr TypeTag(const char *c) : m_class_name(nullptr), m_base(nullptr) { AMS_UNUSED(c); }
-                constexpr TypeTag(const char *c, const TypeTag &b) : m_class_name(nullptr), m_base(std::addressof(b)) { AMS_UNUSED(c); AMS_ASSERT(this != m_base); }
+                constexpr TypeTag(const char *c, const TypeTag &b) : m_class_name(nullptr), m_base(std::addressof(b)) { if (!std::is_constant_evaluated()) { AMS_UNUSED(c); AMS_ASSERT(this != m_base); } }
             #else
                 constexpr TypeTag(const char *c) : m_class_name(c), m_base(nullptr) { /* ... */ }
-                constexpr TypeTag(const char *c, const TypeTag &b) : m_class_name(c), m_base(std::addressof(b)) { AMS_ASSERT(this != m_base); }
+                constexpr TypeTag(const char *c, const TypeTag &b) : m_class_name(c), m_base(std::addressof(b)) { if (!std::is_constant_evaluated()) { AMS_ASSERT(this != m_base); } }
             #endif
 
             constexpr const char * GetClassName() const { return m_class_name; }

libraries/libstratosphere/include/stratosphere/fatal/fatal_types.hpp

@@ -21,6 +21,13 @@
 
 namespace ams::fatal {
 
+    enum FatalPolicy {
+        FatalPolicy_ErrorReportAndErrorScreen = 0,
+        FatalPolicy_ErrorReport               = 1,
+        FatalPolicy_ErrorScreen               = 2
+    };
+
+    #if defined(ATMOSPHERE_ARCH_ARM64)
     namespace aarch64 {
 
         enum RegisterName {
@@ -150,7 +157,7 @@ namespace ams::fatal {
             void SetProgramIdForAtmosphere(ncm::ProgramId program_id) {
                 /* Right now, we mux program ID in through afsr when creport. */
                 /* TODO: Better way to do this? */
-                this->afsr0 = static_cast<RegisterType>(program_id);
+                this->afsr0 = static_cast<RegisterType>(program_id.value);
             }
 
             ncm::ProgramId GetProgramIdForAtmosphere() const {
@@ -172,7 +179,9 @@ namespace ams::fatal {
         };
 
     }
+    #endif
 
+    #if defined(ATMOSPHERE_ARCH_ARM64) || defined(ATMOSPHERE_ARCH_ARM)
     namespace aarch32 {
 
         enum RegisterName {
@@ -268,8 +277,8 @@ namespace ams::fatal {
             void SetProgramIdForAtmosphere(ncm::ProgramId program_id) {
                 /* Right now, we mux program ID in through afsr when creport. */
                 /* TODO: Better way to do this? */
-                this->afsr0 = static_cast<RegisterType>(static_cast<u64>(program_id) >> 0);
+                this->afsr0 = static_cast<RegisterType>(static_cast<u64>(program_id.value) >> 0);
-                this->afsr1 = static_cast<RegisterType>(static_cast<u64>(program_id) >> 32);
+                this->afsr1 = static_cast<RegisterType>(static_cast<u64>(program_id.value) >> 32);
             }
 
             ncm::ProgramId GetProgramIdForAtmosphere() const {
@@ -291,16 +300,158 @@ namespace ams::fatal {
         };
 
     }
+    #endif
+
+    #if defined(ATMOSPHERE_ARCH_X64)
+    namespace x64 {
+
+        enum RegisterName {
+            /* TODO */
+            RegisterName_Count,
+        };
+
+        struct CpuContext {
+            using RegisterType = u64;
+            static constexpr size_t MaxStackTraceDepth = 0x20;
+
+            static constexpr const char *RegisterNameStrings[RegisterName_Count] = {
+                /* TODO */
+            };
+
+            /* Registers, exception context. N left names for these fields in fatal .rodata. */
+            union {
+                // struct {
+                //     /* TODO */
+                // };
+                RegisterType registers[RegisterName_Count];
+            };
+
+            /* Misc. */
+            RegisterType stack_trace[MaxStackTraceDepth];
+            RegisterType base_address;
+            RegisterType register_set_flags;
+            u32 stack_trace_size;
+
+            void ClearState() {
+                std::memset(this, 0, sizeof(*this));
+            }
+
+            void SetProgramIdForAtmosphere(ncm::ProgramId program_id) {
+                AMS_UNUSED(program_id);
+                AMS_ABORT("TODO");
+            }
+
+            ncm::ProgramId GetProgramIdForAtmosphere() const {
+                AMS_ABORT("TODO");
+            }
+
+            void SetRegisterValue(RegisterName name, RegisterType value) {
+                this->registers[name] = value;
+                this->register_set_flags |= (RegisterType(1) << name);
+            }
+
+            bool HasRegisterValue(RegisterName name) const {
+                return this->register_set_flags & (RegisterType(1) << name);
+            }
+
+            void SetBaseAddress(RegisterType base_addr) {
+                this->base_address = base_addr;
+            }
+        };
+
+    }
+    #endif
+
+    #if defined(ATMOSPHERE_ARCH_X64) || defined(ATMOSPHERE_ARCH_X86)
+    namespace x86 {
+
+        enum RegisterName {
+            /* TODO */
+            RegisterName_Count,
+        };
+
+        struct CpuContext {
+            using RegisterType = u32;
+            static constexpr size_t MaxStackTraceDepth = 0x20;
+
+            static constexpr const char *RegisterNameStrings[RegisterName_Count] = {
+                /* TODO */
+            };
+
+            /* Registers, exception context. N left names for these fields in fatal .rodata. */
+            union {
+                // struct {
+                //     /* TODO */
+                // };
+                RegisterType registers[RegisterName_Count];
+            };
+
+            /* Misc. Yes, stack_trace_size is really laid out differently than aarch64... */
+            RegisterType stack_trace[MaxStackTraceDepth];
+            u32 stack_trace_size;
+            RegisterType base_address;
+            RegisterType register_set_flags;
+
+            void ClearState() {
+                std::memset(this, 0, sizeof(*this));
+            }
+
+            void SetProgramIdForAtmosphere(ncm::ProgramId program_id) {
+                AMS_UNUSED(program_id);
+                AMS_ABORT("TODO");
+            }
+
+            ncm::ProgramId GetProgramIdForAtmosphere() const {
+                AMS_ABORT("TODO");
+            }
+
+            void SetRegisterValue(RegisterName name, RegisterType value) {
+                this->registers[name] = value;
+                this->register_set_flags |= (RegisterType(1) << name);
+            }
+
+            bool HasRegisterValue(RegisterName name) const {
+                return this->register_set_flags & (RegisterType(1) << name);
+            }
+
+            void SetBaseAddress(RegisterType base_addr) {
+                this->base_address = base_addr;
+            }
+        };
+
+    }
+    #endif
 
     struct CpuContext : sf::LargeData, sf::PrefersMapAliasTransferMode {
         enum Architecture {
-            Architecture_Aarch64 = 0,
+            #if defined(ATMOSPHERE_ARCH_ARM64)
-            Architecture_Aarch32 = 1,
+            Architecture_Aarch64,
+            #endif
+            #if defined(ATMOSPHERE_ARCH_ARM64) || defined(ATMOSPHERE_ARCH_ARM)
+            Architecture_Aarch32,
+            #endif
+            #if defined(ATMOSPHERE_X64)
+            Architecture_X64,
+            #endif
+            #if defined(ATMOSPHERE_X64) || defined(ATMOSPHERE_ARCH_X86)
+            Architecture_X86,
+            #endif
         };
 
         union {
+            #if defined(ATMOSPHERE_ARCH_ARM64)
             aarch64::CpuContext aarch64_ctx;
+            #endif
+            #if defined(ATMOSPHERE_ARCH_ARM64) || defined(ATMOSPHERE_ARCH_ARM)
             aarch32::CpuContext aarch32_ctx;
+            #endif
+            #if defined(ATMOSPHERE_X64)
+            aarch64::CpuContext x64_ctx;
+            #endif
+            #if defined(ATMOSPHERE_X64) || defined(ATMOSPHERE_ARCH_X86)
+            aarch64::CpuContext x86_ctx;
+            #endif
+            u8 raw_storage[0x248];
         };
 
         Architecture architecture;
@@ -311,8 +462,12 @@ namespace ams::fatal {
         }
     };
 
+    #if defined(ATMOSPHERE_ARCH_ARM64)
     static_assert(util::is_pod<aarch64::CpuContext>::value && sizeof(aarch64::CpuContext) == 0x248, "aarch64::CpuContext definition!");
+    #endif
+    #if defined(ATMOSPHERE_ARCH_ARM64) || defined(ATMOSPHERE_ARCH_ARM)
     static_assert(util::is_pod<aarch32::CpuContext>::value && sizeof(aarch32::CpuContext) == 0xE0,  "aarch32::CpuContext definition!");
+    #endif
     static_assert(util::is_pod<CpuContext>::value          && sizeof(CpuContext) == 0x250,          "CpuContext definition!");
 
     namespace srv {

libraries/libstratosphere/include/stratosphere/fatal/impl/fatal_i_service.hpp

@@ -21,7 +21,7 @@
 
 #define AMS_FATAL_I_SERVICE_INTERFACE_INFO(C, H)                                                                                                                                                                     \
     AMS_SF_METHOD_INFO(C, H, 0, Result, ThrowFatal,               (Result error, const sf::ClientProcessId &client_pid),                                                              (error, client_pid))                  \
-    AMS_SF_METHOD_INFO(C, H, 1, Result, ThrowFatalWithPolicy,     (Result error, const sf::ClientProcessId &client_pid, FatalPolicy policy),                                   (error, client_pid, policy))          \
+    AMS_SF_METHOD_INFO(C, H, 1, Result, ThrowFatalWithPolicy,     (Result error, const sf::ClientProcessId &client_pid, fatal::FatalPolicy policy),                                   (error, client_pid, policy))          \
-    AMS_SF_METHOD_INFO(C, H, 2, Result, ThrowFatalWithCpuContext, (Result error, const sf::ClientProcessId &client_pid, FatalPolicy policy, const fatal::CpuContext &cpu_ctx), (error, client_pid, policy, cpu_ctx))
+    AMS_SF_METHOD_INFO(C, H, 2, Result, ThrowFatalWithCpuContext, (Result error, const sf::ClientProcessId &client_pid, fatal::FatalPolicy policy, const fatal::CpuContext &cpu_ctx), (error, client_pid, policy, cpu_ctx))
 
 AMS_SF_DEFINE_INTERFACE(ams::fatal::impl, IService, AMS_FATAL_I_SERVICE_INTERFACE_INFO)

libraries/libstratosphere/include/stratosphere/fs.hpp

@@ -41,7 +41,9 @@
 #include <stratosphere/fs/fs_speed_emulation.hpp>
 #include <stratosphere/fs/impl/fs_common_mount_name.hpp>
 #include <stratosphere/fs/fs_mount.hpp>
-#include <stratosphere/fs/fs_path_utils.hpp>
+#include <stratosphere/fs/fs_path_utility.hpp>
+#include <stratosphere/fs/fs_path.hpp>
+#include <stratosphere/fs/common/fs_directory_path_parser.hpp>
 #include <stratosphere/fs/fs_filesystem_utils.hpp>
 #include <stratosphere/fs/fs_romfs_filesystem.hpp>
 #include <stratosphere/fs/impl/fs_data.hpp>
@@ -50,8 +52,9 @@
 #include <stratosphere/fs/fs_code.hpp>
 #include <stratosphere/fs/fs_content.hpp>
 #include <stratosphere/fs/fs_content_storage.hpp>
-#include <stratosphere/fs/fs_image_directory.hpp>
 #include <stratosphere/fs/fs_game_card.hpp>
+#include <stratosphere/fs/fs_host.hpp>
+#include <stratosphere/fs/fs_image_directory.hpp>
 #include <stratosphere/fs/fs_save_data_types.hpp>
 #include <stratosphere/fs/fs_save_data_management.hpp>
 #include <stratosphere/fs/fs_save_data_transaction.hpp>

libraries/libstratosphere/include/stratosphere/fs/common/fs_directory_path_parser.hpp

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere/fs/fs_common.hpp>
+#include <stratosphere/fs/fs_path.hpp>
+
+namespace ams::fs {
+
+    class DirectoryPathParser {
+        NON_COPYABLE(DirectoryPathParser);
+        NON_MOVEABLE(DirectoryPathParser);
+        private:
+            char *m_buffer;
+            char m_replaced_char;
+            s32 m_position;
+            fs::Path m_current_path;
+        public:
+            DirectoryPathParser() : m_buffer(nullptr), m_replaced_char(StringTraits::NullTerminator), m_position(0), m_current_path() { /* ... */ }
+
+            const fs::Path &GetCurrentPath() const {
+                return m_current_path;
+            }
+
+            Result Initialize(fs::Path *path) {
+                /* Declare a default buffer, in case the path has no write buffer. */
+                static constinit char EmptyBuffer[1] = "";
+
+                /* Get a usable buffer. */
+                char *buf = path->GetWriteBufferLength() > 0 ? path->GetWriteBuffer() : EmptyBuffer;
+
+                /* Get the windows skip length. */
+                const auto windows_skip_len = fs::GetWindowsSkipLength(buf);
+
+                /* Set our buffer. */
+                m_buffer = buf + windows_skip_len;
+
+                /* Set up our initial state. */
+                if (windows_skip_len) {
+                    R_TRY(m_current_path.InitializeWithNormalization(buf, windows_skip_len + 1));
+                } else {
+                    if (char * const first = this->ReadNextImpl(); first != nullptr) {
+                        R_TRY(m_current_path.InitializeWithNormalization(first));
+                    }
+                }
+
+                R_SUCCEED();
+            }
+
+            Result ReadNext(bool *out_finished) {
+                /* Default to not finished. */
+                *out_finished = false;
+
+                /* Get the next child component. */
+                if (auto * const child = this->ReadNextImpl(); child != nullptr) {
+                    /* Append the child component to our current path. */
+                    R_TRY(m_current_path.AppendChild(child));
+                } else {
+                    /* We have no child component, so we're finished. */
+                    *out_finished = true;
+                }
+
+                R_SUCCEED();
+            }
+        private:
+            char *ReadNextImpl() {
+                /* Check that we have characters to read. */
+                if (m_position < 0 || m_buffer[0] == StringTraits::NullTerminator) {
+                    return nullptr;
+                }
+
+                /* If we have a replaced character, restore it. */
+                if (m_replaced_char != StringTraits::NullTerminator) {
+                    m_buffer[m_position] = m_replaced_char;
+                    if (m_replaced_char == StringTraits::DirectorySeparator) {
+                        ++m_position;
+                    }
+                }
+
+                /* If we're at the start of a root-relative path, begin by returning the root. */
+                if (m_position == 0 && m_buffer[0] == StringTraits::DirectorySeparator) {
+                    m_replaced_char = m_buffer[1];
+                    m_buffer[1]     = StringTraits::NullTerminator;
+                    m_position      = 1;
+                    return m_buffer;
+                }
+
+                /* Otherwise, find the end of the next path component. */
+                s32 i;
+                for (i = m_position; m_buffer[i] != StringTraits::DirectorySeparator; ++i) {
+                    if (m_buffer[i] == StringTraits::NullTerminator) {
+                        if (i == m_position) {
+                            m_position = -1;
+                            return nullptr;
+                        }
+                    }
+                }
+
+                /* Sanity check that we're not ending on a separator. */
+                AMS_ASSERT(m_buffer[i + 1] != StringTraits::NullTerminator);
+
+                char * const ret = m_buffer + m_position;
+
+                m_replaced_char = StringTraits::DirectorySeparator;
+                m_buffer[i]     = 0;
+                m_position      = i;
+
+                return ret;
+            }
+    };
+
+}

libraries/libstratosphere/include/stratosphere/fs/common/fs_file_storage.hpp

@@ -82,7 +82,7 @@ namespace ams::fs {
         public:
             constexpr FileStorageBasedFileSystem() : FileStorage(), m_base_file_system(nullptr) { /* ... */ }
 
-            Result Initialize(std::shared_ptr<fs::fsa::IFileSystem> base_file_system, const char *path, fs::OpenMode mode);
+            Result Initialize(std::shared_ptr<fs::fsa::IFileSystem> base_file_system, const fs::Path &path, fs::OpenMode mode);
     };
 
     class FileHandleStorage : public IStorage, public impl::Newable {

libraries/libstratosphere/include/stratosphere/fs/fs_directory.hpp

@@ -20,7 +20,13 @@ namespace ams::fs {
 
     constexpr inline size_t EntryNameLengthMax = 0x300;
 
-    using DirectoryEntry = ::FsDirectoryEntry;
+    struct DirectoryEntry {
+        char name[EntryNameLengthMax + 1];
+        char pad[3];
+        s8 type;
+        u8 pad2[3];
+        s64 file_size;
+    };
 
     struct DirectoryHandle {
         void *handle;

libraries/libstratosphere/include/stratosphere/fs/fs_file.hpp

@@ -24,7 +24,11 @@ namespace ams::fs {
         static const ReadOption None;
     };
 
-    inline constexpr const ReadOption ReadOption::None = {FsReadOption_None};
+    enum ReadOptionFlag : u32 {
+        ReadOptionFlag_None = (0 << 0),
+    };
+
+    inline constexpr const ReadOption ReadOption::None = {ReadOptionFlag_None};
 
     inline constexpr bool operator==(const ReadOption &lhs, const ReadOption &rhs) {
         return lhs._value == rhs._value;
@@ -36,19 +40,24 @@ namespace ams::fs {
 
     static_assert(util::is_pod<ReadOption>::value && sizeof(ReadOption) == sizeof(u32));
 
+    enum WriteOptionFlag : u32 {
+        WriteOptionFlag_None  = (0 << 0),
+        WriteOptionFlag_Flush = (1 << 0),
+    };
+
     struct WriteOption {
         u32 _value;
 
         constexpr inline bool HasFlushFlag() const {
-            return _value & FsWriteOption_Flush;
+            return _value & WriteOptionFlag_Flush;
         }
 
         static const WriteOption None;
         static const WriteOption Flush;
     };
 
-    inline constexpr const WriteOption WriteOption::None = {FsWriteOption_None};
+    inline constexpr const WriteOption WriteOption::None = {WriteOptionFlag_None};
-    inline constexpr const WriteOption WriteOption::Flush = {FsWriteOption_Flush};
+    inline constexpr const WriteOption WriteOption::Flush = {WriteOptionFlag_Flush};
 
     inline constexpr bool operator==(const WriteOption &lhs, const WriteOption &rhs) {
         return lhs._value == rhs._value;

libraries/libstratosphere/include/stratosphere/fs/fs_filesystem.hpp

@@ -34,23 +34,23 @@ namespace ams::fs {
     };
 
     enum OpenDirectoryMode {
-        OpenDirectoryMode_Directory = ::FsDirOpenMode_ReadDirs,
+        OpenDirectoryMode_Directory = (1 << 0),
-        OpenDirectoryMode_File      = ::FsDirOpenMode_ReadFiles,
+        OpenDirectoryMode_File      = (1 << 1),
 
         OpenDirectoryMode_All = (OpenDirectoryMode_Directory | OpenDirectoryMode_File),
 
         /* TODO: Separate enum, like N? */
-        OpenDirectoryMode_NotRequireFileSize = ::FsDirOpenMode_NoFileSize,
+        OpenDirectoryMode_NotRequireFileSize = (1 << 31),
     };
 
     enum DirectoryEntryType {
-        DirectoryEntryType_Directory = ::FsDirEntryType_Dir,
+        DirectoryEntryType_Directory = 0,
-        DirectoryEntryType_File      = ::FsDirEntryType_File,
+        DirectoryEntryType_File      = 1,
     };
 
     enum CreateOption {
-        CreateOption_None    = 0,
+        CreateOption_None    = (0 << 0),
-        CreateOption_BigFile = ::FsCreateOption_BigFile,
+        CreateOption_BigFile = (1 << 0),
     };
 
     struct FileHandle;

libraries/libstratosphere/include/stratosphere/fs/fs_filesystem_for_debug.hpp

@@ -16,10 +16,37 @@
 #pragma once
 #include <stratosphere/fs/fs_common.hpp>
 #include <stratosphere/fs/fs_filesystem.hpp>
+#include <stratosphere/time/time_posix_time.hpp>
 
 namespace ams::fs {
 
-    using FileTimeStampRaw = ::FsTimeStampRaw;
+    struct FileTimeStamp {
+        time::PosixTime create;
+        time::PosixTime modify;
+        time::PosixTime access;
+        bool is_local_time;
+        char pad[7];
+    };
+    static_assert(util::is_pod<FileTimeStamp>::value && sizeof(FileTimeStamp) == 0x20);
+
+    struct FileTimeStampRaw {
+        s64 create;
+        s64 modify;
+        s64 access;
+        bool is_local_time;
+        char pad[7];
+    };
+    static_assert(util::is_pod<FileTimeStampRaw>::value && sizeof(FileTimeStampRaw) == 0x20);
+
+    static_assert(__builtin_offsetof(FileTimeStampRaw, create) == __builtin_offsetof(FileTimeStampRaw, create));
+    static_assert(__builtin_offsetof(FileTimeStampRaw, modify) == __builtin_offsetof(FileTimeStampRaw, modify));
+    static_assert(__builtin_offsetof(FileTimeStampRaw, access) == __builtin_offsetof(FileTimeStampRaw, access));
+    static_assert(__builtin_offsetof(FileTimeStampRaw, is_local_time) == __builtin_offsetof(FileTimeStampRaw, is_local_time));
+    static_assert(__builtin_offsetof(FileTimeStampRaw, pad) == __builtin_offsetof(FileTimeStampRaw, pad));
+
+    #if defined(ATMOSPHERE_OS_HORIZON)
+    static_assert(sizeof(FileTimeStampRaw) == sizeof(::FsTimeStampRaw));
+    #endif
 
     namespace impl {
 
@@ -27,6 +54,6 @@ namespace ams::fs {
 
     }
 
-    Result GetFileTimeStampRawForDebug(FileTimeStampRaw *out, const char *path);
+    Result GetFileTimeStamp(FileTimeStamp *out, const char *path);
 
 }

libraries/libstratosphere/include/stratosphere/fs/fs_filesystem_utils.hpp

@@ -21,8 +21,8 @@
 namespace ams::fs {
 
     /* Common utilities. */
-    Result EnsureDirectoryRecursively(const char *path);
+    Result EnsureDirectory(const char *path);
-    Result EnsureParentDirectoryRecursively(const char *path);
+    Result EnsureParentDirectory(const char *path);
 
     Result HasFile(bool *out, const char *path);
     Result HasDirectory(bool *out, const char *path);

libraries/libstratosphere/include/stratosphere/fs/fs_host.hpp

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere/fs/fs_common.hpp>
+#include <stratosphere/ncm/ncm_ids.hpp>
+#include <stratosphere/fs/fs_code_verification_data.hpp>
+
+namespace ams::fs {
+
+    enum MountHostOptionFlag : u32 {
+        MountHostOptionFlag_None                = (0 << 0),
+        MountHostOptionFlag_PseudoCaseSensitive = (1 << 0),
+    };
+
+    struct MountHostOption {
+        u32 _value;
+
+        constexpr inline bool HasPseudoCaseSensitiveFlag() const {
+            return _value & MountHostOptionFlag_PseudoCaseSensitive;
+        }
+
+        static const MountHostOption None;
+        static const MountHostOption PseudoCaseSensitive;
+    };
+
+    inline constexpr const MountHostOption MountHostOption::None                = {MountHostOptionFlag_None};
+    inline constexpr const MountHostOption MountHostOption::PseudoCaseSensitive = {MountHostOptionFlag_PseudoCaseSensitive};
+
+    inline constexpr bool operator==(const MountHostOption &lhs, const MountHostOption &rhs) {
+        return lhs._value == rhs._value;
+    }
+
+    inline constexpr bool operator!=(const MountHostOption &lhs, const MountHostOption &rhs) {
+        return !(lhs == rhs);
+    }
+
+    Result MountHost(const char *name, const char *root_path);
+    Result MountHost(const char *name, const char *root_path, const MountHostOption &option);
+
+    Result MountHostRoot();
+    Result MountHostRoot(const MountHostOption &option);
+
+    void UnmountHostRoot();
+
+}

libraries/libstratosphere/include/stratosphere/fs/fs_istorage.hpp

@@ -68,13 +68,13 @@ namespace ams::fs {
             std::unique_ptr<IStorage> m_unique_storage;
             IStorage *m_storage;
         public:
-            ReadOnlyStorageAdapter(IStorage *s) : m_unique_storage(s) {
+            explicit ReadOnlyStorageAdapter(IStorage *s) : m_unique_storage(s) {
                 m_storage = m_unique_storage.get();
             }
-            ReadOnlyStorageAdapter(std::shared_ptr<IStorage> s) : m_shared_storage(s) {
+            explicit ReadOnlyStorageAdapter(std::shared_ptr<IStorage> s) : m_shared_storage(s) {
                 m_storage = m_shared_storage.get();
             }
-            ReadOnlyStorageAdapter(std::unique_ptr<IStorage> s) : m_unique_storage(std::move(s)) {
+            explicit ReadOnlyStorageAdapter(std::unique_ptr<IStorage> s) : m_unique_storage(std::move(s)) {
                 m_storage = m_unique_storage.get();
             }
 

libraries/libstratosphere/include/stratosphere/fs/fs_path.hpp

@@ -0,0 +1,582 @@
+/*
+ * Copyright (c) Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <stratosphere/fs/fs_common.hpp>
+#include <stratosphere/fs/fs_memory_management.hpp>
+#include <stratosphere/fs/impl/fs_common_mount_name.hpp>
+#include <stratosphere/fs/fs_path_utility.hpp>
+
+namespace ams::fs {
+
+    class DirectoryPathParser;
+
+    class Path {
+        NON_COPYABLE(Path);
+        NON_MOVEABLE(Path);
+        private:
+            static constexpr const char *EmptyPath = "";
+            static constexpr size_t WriteBufferAlignmentLength = 8;
+        private:
+            friend class DirectoryPathParser;
+        private:
+            using WriteBuffer = std::unique_ptr<char[], ::ams::fs::impl::Deleter>;
+        private:
+            const char *m_str;
+            util::TypedStorage<WriteBuffer> m_write_buffer;
+            size_t m_write_buffer_length;
+            bool m_is_normalized;
+        public:
+            Path() : m_str(EmptyPath), m_write_buffer_length(0), m_is_normalized(false) {
+                util::ConstructAt(m_write_buffer, nullptr);
+            }
+
+            constexpr Path(const char *s, util::ConstantInitializeTag) : m_str(s), m_write_buffer(), m_write_buffer_length(0), m_is_normalized(true) {
+                /* ... */
+            }
+
+            constexpr ~Path() {
+                if (!std::is_constant_evaluated()) {
+                    util::DestroyAt(m_write_buffer);
+                }
+            }
+
+            WriteBuffer ReleaseBuffer() {
+                /* Check pre-conditions. */
+                AMS_ASSERT(util::GetReference(m_write_buffer) != nullptr);
+
+                /* Reset. */
+                m_str                 = EmptyPath;
+                m_write_buffer_length = 0;
+
+                /* Return our write buffer. */
+                return std::move(util::GetReference(m_write_buffer));
+            }
+
+            constexpr Result SetShallowBuffer(const char *buffer) {
+                /* Check pre-conditions. */
+                AMS_ASSERT(m_write_buffer_length == 0);
+
+                /* Check the buffer is valid. */
+                R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
+
+                /* Set buffer. */
+                this->SetReadOnlyBuffer(buffer);
+
+                /* Note that we're normalized. */
+                m_is_normalized = true;
+
+                R_SUCCEED();
+            }
+
+            const char *GetString() const {
+                /* Check pre-conditions. */
+                AMS_ASSERT(m_is_normalized);
+
+                return m_str;
+            }
+
+            size_t GetLength() const {
+                return std::strlen(this->GetString());
+            }
+
+            bool IsEmpty() const {
+                return *m_str == '\x00';
+            }
+
+            bool IsMatchHead(const char *p, size_t len) const {
+                return util::Strncmp(this->GetString(), p, len) == 0;
+            }
+
+            Result Initialize(const Path &rhs) {
+                /* Check the other path is normalized. */
+                R_UNLESS(rhs.m_is_normalized, fs::ResultNotNormalized());
+
+                /* Allocate buffer for our path. */
+                const auto len = rhs.GetLength();
+                R_TRY(this->Preallocate(len + 1));
+
+                /* Copy the path. */
+                const size_t copied = util::Strlcpy<char>(util::GetReference(m_write_buffer).get(), rhs.GetString(), len + 1);
+                R_UNLESS(copied == len, fs::ResultUnexpectedInPathA());
+
+                /* Set normalized. */
+                m_is_normalized = rhs.m_is_normalized;
+                R_SUCCEED();
+            }
+
+            Result Initialize(const char *path, size_t len) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                /* Initialize. */
+                R_TRY(this->InitializeImpl(path, len));
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                R_SUCCEED();
+            }
+
+            Result Initialize(const char *path) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                return this->Initialize(path, std::strlen(path));
+            }
+
+            Result InitializeWithFormat(const char *fmt, ...) __attribute__((format (printf, 2, 3))) {
+                /* Check the format string is valid. */
+                R_UNLESS(fmt != nullptr, fs::ResultNullptrArgument());
+
+                /* Create the va_list for formatting. */
+                std::va_list vl;
+                va_start(vl, fmt);
+
+                /* Determine how big the string will be. */
+                char dummy;
+                const auto len = util::VSNPrintf(std::addressof(dummy), 0, fmt, vl);
+
+                /* Allocate buffer for our path. */
+                R_TRY(this->Preallocate(len + 1));
+
+                /* Format our path into our new buffer. */
+                const auto real_len = util::VSNPrintf(util::GetReference(m_write_buffer).get(), m_write_buffer_length, fmt, vl);
+                AMS_ASSERT(real_len == len);
+                AMS_UNUSED(real_len);
+
+                /* Finish the va_list. */
+                va_end(vl);
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                R_SUCCEED();
+            }
+
+            Result InitializeWithReplaceBackslash(const char *path) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                /* Initialize. */
+                R_TRY(this->InitializeImpl(path, std::strlen(path)));
+
+                /* Replace slashes as desired. */
+                if (m_write_buffer_length > 1) {
+                    fs::Replace(this->GetWriteBuffer(), m_write_buffer_length - 1, '\\', '/');
+                }
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                R_SUCCEED();
+            }
+
+            Result InitializeWithReplaceForwardSlashes(const char *path) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                /* Initialize. */
+                R_TRY(this->InitializeImpl(path, std::strlen(path)));
+
+                /* Replace slashes as desired. */
+                if (m_write_buffer_length > 1) {
+                    if (auto *p = this->GetWriteBuffer(); p[0] == '/' && p[1] == '/') {
+                        p[0] = '\\';
+                        p[1] = '\\';
+                    }
+                }
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                R_SUCCEED();
+            }
+
+            Result InitializeWithReplaceUnc(const char *path) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                /* Initialize. */
+                R_TRY(this->InitializeImpl(path, std::strlen(path)));
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                /* Replace unc as desired. */
+                if (m_str[0]) {
+                    auto *p = this->GetWriteBuffer();
+
+                    /* Replace :/// -> \\ as needed. */
+                    if (auto *sep = std::strstr(p, ":///"); sep != nullptr) {
+                        sep[0] = '\\';
+                        sep[1] = '\\';
+                    }
+
+                    /* Edit path prefix. */
+                    if (!util::Strncmp(p, AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME AMS_FS_IMPL_MOUNT_NAME_DELIMITER "/", AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME_LEN + AMS_FS_IMPL_MOUNT_NAME_DELIMITER_LEN + 1)) {
+                        static_assert((AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME AMS_FS_IMPL_MOUNT_NAME_DELIMITER)[AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME_LEN + AMS_FS_IMPL_MOUNT_NAME_DELIMITER_LEN - 1] == '/');
+
+                        p[AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME_LEN + AMS_FS_IMPL_MOUNT_NAME_DELIMITER_LEN - 1] = '\\';
+                        p[AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME_LEN + AMS_FS_IMPL_MOUNT_NAME_DELIMITER_LEN - 0] = '\\';
+                    }
+
+                    if (p[0] == '/' && p[1] == '/') {
+                        p[0] = '\\';
+                        p[1] = '\\';
+                    }
+                }
+
+                R_SUCCEED();
+            }
+
+            Result InitializeWithNormalization(const char *path, size_t size) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                /* Initialize. */
+                R_TRY(this->InitializeImpl(path, size));
+
+                /* Set not normalized. */
+                m_is_normalized = false;
+
+                /* Perform normalization. */
+                fs::PathFlags path_flags;
+                if (fs::IsPathRelative(m_str)) {
+                    path_flags.AllowRelativePath();
+                } else if (fs::IsWindowsPath(m_str, true)) {
+                    path_flags.AllowWindowsPath();
+                } else {
+                    /* NOTE: In this case, Nintendo checks is normalized, then sets is normalized, then returns success. */
+                    /* This seems like a bug. */
+                    size_t dummy;
+                    R_TRY(PathFormatter::IsNormalized(std::addressof(m_is_normalized), std::addressof(dummy), m_str));
+
+                    m_is_normalized = true;
+                    R_SUCCEED();
+                }
+
+                /* Normalize. */
+                R_TRY(this->Normalize(path_flags));
+
+                m_is_normalized = true;
+                R_SUCCEED();
+            }
+
+            Result InitializeWithNormalization(const char *path) {
+                /* Check the path is valid. */
+                R_UNLESS(path != nullptr, fs::ResultNullptrArgument());
+
+                R_RETURN(this->InitializeWithNormalization(path, std::strlen(path)));
+            }
+
+            Result InitializeAsEmpty() {
+                /* Clear our buffer. */
+                this->ClearBuffer();
+
+                /* Set normalized. */
+                m_is_normalized = true;
+
+                R_SUCCEED();
+            }
+
+            Result AppendChild(const char *child) {
+                /* Check the path is valid. */
+                R_UNLESS(child != nullptr, fs::ResultNullptrArgument());
+
+                /* Basic checks. If we hvea a path and the child is empty, we have nothing to do. */
+                const char *c = child;
+                if (m_str[0]) {
+                    /* Skip an early separator. */
+                    if (*c == '/') {
+                        ++c;
+                    }
+
+                    R_SUCCEED_IF(*c == '\x00');
+                }
+
+                /* If we don't have a string, we can just initialize. */
+                auto cur_len = std::strlen(m_str);
+                if (cur_len == 0) {
+                    R_RETURN(this->Initialize(child));
+                }
+
+                /* Remove a trailing separator. */
+                if (m_str[cur_len - 1] == '/' || m_str[cur_len - 1] == '\\') {
+                    --cur_len;
+                }
+
+                /* Get the child path's length. */
+                auto child_len = std::strlen(c);
+
+                /* Reset our write buffer. */
+                WriteBuffer old_write_buffer;
+                if (util::GetReference(m_write_buffer) != nullptr) {
+                    old_write_buffer = std::move(util::GetReference(m_write_buffer));
+                    this->ClearBuffer();
+                }
+
+                /* Pre-allocate the new buffer. */
+                R_TRY(this->Preallocate(cur_len + 1 + child_len + 1));
+
+                /* Get our write buffer. */
+                auto *dst = this->GetWriteBuffer();
+                if (old_write_buffer != nullptr && cur_len > 0) {
+                    util::Strlcpy<char>(dst, old_write_buffer.get(), cur_len + 1);
+                }
+
+                /* Add separator. */
+                dst[cur_len] = '/';
+
+                /* Copy the child path. */
+                const size_t copied = util::Strlcpy<char>(dst + cur_len + 1, c, child_len + 1);
+                R_UNLESS(copied == child_len, fs::ResultUnexpectedInPathA());
+
+                R_SUCCEED();
+            }
+
+            Result AppendChild(const Path &rhs) {
+                R_RETURN(this->AppendChild(rhs.GetString()));
+            }
+
+            Result Combine(const Path &parent, const Path &child) {
+                /* Get the lengths. */
+                const auto p_len = parent.GetLength();
+                const auto c_len = child.GetLength();
+
+                /* Allocate our buffer. */
+                R_TRY(this->Preallocate(p_len + c_len + 1));
+
+                /* Initialize as parent. */
+                R_TRY(this->Initialize(parent));
+
+                /* If we're empty, we can just initialize as child. */
+                if (this->IsEmpty()) {
+                    R_TRY(this->Initialize(child));
+                } else {
+                    /* Otherwise, we should append the child. */
+                    R_TRY(this->AppendChild(child));
+                }
+
+                R_SUCCEED();
+            }
+
+            Result RemoveChild() {
+                /* If we don't have a write-buffer, ensure that we have one. */
+                if (util::GetReference(m_write_buffer) == nullptr) {
+                    if (const auto len = std::strlen(m_str); len > 0) {
+                        R_TRY(this->Preallocate(len));
+                        util::Strlcpy<char>(util::GetReference(m_write_buffer).get(), m_str, len + 1);
+                    }
+                }
+
+                /* Check that it's possible for us to remove a child. */
+                auto *p = this->GetWriteBuffer();
+                s32 len = std::strlen(p);
+                R_UNLESS(len != 1 || (p[0] != '/' && p[0] != '.'), fs::ResultNotImplemented());
+
+                /* Handle a trailing separator. */
+                if (len > 0 && (p[len - 1] == '\\' || p[len - 1] == '/')) {
+                    --len;
+                }
+
+                /* Remove the child path segment. */
+                while ((--len) >= 0 && p[len]) {
+                    if (p[len] == '/' || p[len] == '\\') {
+                        if (len > 0) {
+                            p[len] = 0;
+                        } else {
+                            p[1] = 0;
+                            len  = 1;
+                        }
+                        break;
+                    }
+                }
+
+                /* Check that length remains > 0. */
+                R_UNLESS(len > 0, fs::ResultNotImplemented());
+
+                R_SUCCEED();
+            }
+
+            Result Normalize(const PathFlags &flags) {
+                /* If we're already normalized, nothing to do. */
+                R_SUCCEED_IF(m_is_normalized);
+
+                /* Check if we're normalized. */
+                bool normalized;
+                size_t dummy;
+                R_TRY(PathFormatter::IsNormalized(std::addressof(normalized), std::addressof(dummy), m_str, flags));
+
+                /* If we're not normalized, normalize. */
+                if (!normalized) {
+                    /* Determine necessary buffer length. */
+                    auto len = m_write_buffer_length;
+                    if (flags.IsRelativePathAllowed() && fs::IsPathRelative(m_str)) {
+                        len += 2;
+                    }
+                    if (flags.IsWindowsPathAllowed() && fs::IsWindowsPath(m_str, true)) {
+                        len += 1;
+                    }
+
+                    /* Allocate a new buffer. */
+                    const size_t size = util::AlignUp(len, WriteBufferAlignmentLength);
+                    auto buf = fs::impl::MakeUnique<char[]>(size);
+                    R_UNLESS(buf != nullptr, fs::ResultAllocationFailureInMakeUnique());
+
+                    /* Normalize into it. */
+                    R_TRY(PathFormatter::Normalize(buf.get(), size, util::GetReference(m_write_buffer).get(), m_write_buffer_length, flags));
+
+                    /* Set the normalized buffer as our buffer. */
+                    this->SetModifiableBuffer(std::move(buf), size);
+                }
+
+                /* Set normalized. */
+                m_is_normalized = true;
+                R_SUCCEED();
+            }
+        private:
+            void ClearBuffer() {
+                util::GetReference(m_write_buffer).reset();
+                m_write_buffer_length = 0;
+                m_str = EmptyPath;
+            }
+
+            void SetModifiableBuffer(WriteBuffer &&buffer, size_t size) {
+                /* Check pre-conditions. */
+                AMS_ASSERT(buffer.get() != nullptr);
+                AMS_ASSERT(size > 0);
+                AMS_ASSERT(util::IsAligned(size, WriteBufferAlignmentLength));
+
+                /* Set write buffer. */
+                util::GetReference(m_write_buffer) = std::move(buffer);
+                m_write_buffer_length              = size;
+                m_str                              = util::GetReference(m_write_buffer).get();
+            }
+
+            constexpr void SetReadOnlyBuffer(const char *buffer) {
+                m_str = buffer;
+                if (!std::is_constant_evaluated()) {
+                    util::GetReference(m_write_buffer) = nullptr;
+                    m_write_buffer_length              = 0;
+                }
+            }
+
+            Result Preallocate(size_t length) {
+                /* Allocate additional space, if needed. */
+                if (length > m_write_buffer_length) {
+                    /* Allocate buffer. */
+                    const size_t size = util::AlignUp(length, WriteBufferAlignmentLength);
+                    auto buf = fs::impl::MakeUnique<char[]>(size);
+                    R_UNLESS(buf != nullptr, fs::ResultAllocationFailureInMakeUnique());
+
+                    /* Set write buffer. */
+                    this->SetModifiableBuffer(std::move(buf), size);
+                }
+
+                R_SUCCEED();
+            }
+
+            Result InitializeImpl(const char *path, size_t size) {
+                if (size > 0 && path[0]) {
+                    /* Pre allocate a buffer for the path. */
+                    R_TRY(this->Preallocate(size + 1));
+
+                    /* Copy the path. */
+                    const size_t copied = util::Strlcpy<char>(this->GetWriteBuffer(), path, size + 1);
+                    R_UNLESS(copied >= size, fs::ResultUnexpectedInPathA());
+                } else {
+                    /* We can just clear the buffer. */
+                    this->ClearBuffer();
+                }
+
+                R_SUCCEED();
+            }
+
+            char *GetWriteBuffer() {
+                AMS_ASSERT(util::GetReference(m_write_buffer) != nullptr);
+                return util::GetReference(m_write_buffer).get();
+            }
+
+            size_t GetWriteBufferLength() const {
+                return m_write_buffer_length;
+            }
+        public:
+            ALWAYS_INLINE bool operator==(const fs::Path &rhs) const { return std::strcmp(this->GetString(), rhs.GetString()) == 0; }
+            ALWAYS_INLINE bool operator!=(const fs::Path &rhs) const { return !(*this == rhs); }
+            ALWAYS_INLINE bool operator==(const char *p) const { return std::strcmp(this->GetString(), p) == 0; }
+            ALWAYS_INLINE bool operator!=(const char *p) const { return !(*this == p); }
+    };
+
+    consteval fs::Path MakeConstantPath(const char *s) { return fs::Path(s, util::ConstantInitializeTag{}); }
+
+    inline Result SetUpFixedPath(fs::Path *out, const char *s) {
+        /* Verify the path is normalized. */
+        bool normalized;
+        size_t dummy;
+        R_TRY(PathNormalizer::IsNormalized(std::addressof(normalized), std::addressof(dummy), s));
+
+        R_UNLESS(normalized, fs::ResultInvalidPathFormat());
+
+        /* Set the fixed path. */
+        R_RETURN(out->SetShallowBuffer(s));
+    }
+
+    inline Result SetUpFixedPathSingleEntry(fs::Path *out, char *buf, size_t buf_size, const char *e) {
+        /* Print the path into the buffer. */
+        const size_t len = util::TSNPrintf(buf, buf_size, "/%s", e);
+        R_UNLESS(len < buf_size, fs::ResultInvalidArgument());
+
+        /* Set up the path. */
+        R_RETURN(SetUpFixedPath(out, buf));
+    }
+
+    inline Result SetUpFixedPathDoubleEntry(fs::Path *out, char *buf, size_t buf_size, const char *e, const char *e2) {
+        /* Print the path into the buffer. */
+        const size_t len = util::TSNPrintf(buf, buf_size, "/%s/%s", e, e2);
+        R_UNLESS(len < buf_size, fs::ResultInvalidArgument());
+
+        /* Set up the path. */
+        R_RETURN(SetUpFixedPath(out, buf));
+    }
+
+    inline Result SetUpFixedPathSaveId(fs::Path *out, char *buf, size_t buf_size, u64 id) {
+        /* Print the path into the buffer. */
+        const size_t len = util::TSNPrintf(buf, buf_size, "/%016" PRIx64 "", id);
+        R_UNLESS(len < buf_size, fs::ResultInvalidArgument());
+
+        /* Set up the path. */
+        R_RETURN(SetUpFixedPath(out, buf));
+    }
+
+    inline Result SetUpFixedPathSaveMetaName(fs::Path *out, char *buf, size_t buf_size, u32 type) {
+        /* Print the path into the buffer. */
+        const size_t len = util::TSNPrintf(buf, buf_size, "/%08" PRIx32 ".meta", type);
+        R_UNLESS(len < buf_size, fs::ResultInvalidArgument());
+
+        /* Set up the path. */
+        R_RETURN(SetUpFixedPath(out, buf));
+    }
+
+    inline Result SetUpFixedPathSaveMetaDir(fs::Path *out, char *buf, size_t buf_size, u64 id) {
+        /* Print the path into the buffer. */
+        const size_t len = util::TSNPrintf(buf, buf_size, "/saveMeta/%016" PRIx64 "", id);
+        R_UNLESS(len < buf_size, fs::ResultInvalidArgument());
+
+        /* Set up the path. */
+        R_RETURN(SetUpFixedPath(out, buf));
+    }
+
+}

libraries/libstratosphere/include/stratosphere/fs/fs_path_utils.hpp

@@ -1,123 +0,0 @@
-/*
- * Copyright (c) Atmosphère-NX
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-#pragma once
-#include <stratosphere/fs/fs_common.hpp>
-#include <stratosphere/fssrv/sf/fssrv_sf_path.hpp>
-
-namespace ams::fs {
-
-    namespace StringTraits {
-
-        constexpr inline char DirectorySeparator = '/';
-        constexpr inline char DriveSeparator     = ':';
-        constexpr inline char Dot                = '.';
-        constexpr inline char NullTerminator     = '\x00';
-
-        constexpr inline char AlternateDirectorySeparator = '\\';
-
-    }
-
-    /* Windows path utilities. */
-    constexpr inline bool IsWindowsDrive(const char *path) {
-        AMS_ASSERT(path != nullptr);
-
-        const char c = path[0];
-        return (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z')) && path[1] == StringTraits::DriveSeparator;
-    }
-
-    constexpr inline bool IsUnc(const char *path) {
-        return (path[0] == StringTraits::DirectorySeparator && path[1] == StringTraits::DirectorySeparator) ||
-               (path[0] == StringTraits::AlternateDirectorySeparator && path[1] == StringTraits::AlternateDirectorySeparator);
-    }
-
-    constexpr inline s64 GetWindowsPathSkipLength(const char *path) {
-        if (IsWindowsDrive(path)) {
-            return 2;
-        }
-        if (IsUnc(path)) {
-            for (s64 i = 2; path[i] != StringTraits::NullTerminator; ++i) {
-                if (path[i] == '$' || path[i] == ':') {
-                    return i + 1;
-                }
-            }
-        }
-        return 0;
-    }
-
-    /* Path utilities. */
-    inline void Replace(char *dst, size_t dst_size, char old_char, char new_char) {
-        AMS_ASSERT(dst != nullptr);
-        for (char *cur = dst; cur < dst + dst_size && *cur != StringTraits::NullTerminator; ++cur) {
-            if (*cur == old_char) {
-                *cur = new_char;
-            }
-        }
-    }
-
-    Result FspPathPrintf(fssrv::sf::FspPath *dst, const char *format, ...) __attribute__((format(printf, 2, 3)));
-
-    inline Result FspPathPrintf(fssrv::sf::FspPath *dst, const char *format, ...) {
-        AMS_ASSERT(dst != nullptr);
-
-        /* Format the path. */
-        std::va_list va_list;
-        va_start(va_list, format);
-        const size_t len = util::VSNPrintf(dst->str, sizeof(dst->str), format, va_list);
-        va_end(va_list);
-
-        /* Validate length. */
-        R_UNLESS(len < sizeof(dst->str), fs::ResultTooLongPath());
-
-        /* Fix slashes. */
-        Replace(dst->str, sizeof(dst->str) - 1, '\\', '/');
-
-        return ResultSuccess();
-    }
-
-    Result VerifyPath(const char *path, int max_path_len, int max_name_len);
-
-    bool IsSubPath(const char *lhs, const char *rhs);
-
-    /* Path normalization. */
-    class PathNormalizer {
-        public:
-            static constexpr const char RootPath[] = "/";
-        public:
-            static constexpr inline bool IsSeparator(char c) {
-                return c == StringTraits::DirectorySeparator;
-            }
-
-            static constexpr inline bool IsAnySeparator(char c) {
-                return c == StringTraits::DirectorySeparator || c == StringTraits::AlternateDirectorySeparator;
-            }
-
-            static constexpr inline bool IsNullTerminator(char c) {
-                return c == StringTraits::NullTerminator;
-            }
-
-            static constexpr inline bool IsCurrentDirectory(const char *p) {
-                return p[0] == StringTraits::Dot && (IsSeparator(p[1]) || IsNullTerminator(p[1]));
-            }
-
-            static constexpr inline bool IsParentDirectory(const char *p) {
-                return p[0] == StringTraits::Dot && p[1] == StringTraits::Dot && (IsSeparator(p[2]) || IsNullTerminator(p[2]));
-            }
-
-            static Result Normalize(char *out, size_t *out_len, const char *src, size_t max_out_size, bool unc_preserved = false, bool has_mount_name = false);
-            static Result IsNormalized(bool *out, const char *path, bool unc_preserved = false, bool has_mount_name = false);
-    };
-
-}

libraries/libstratosphere/include/stratosphere/fs/fs_query_range.hpp

@@ -38,7 +38,10 @@ namespace ams::fs {
 
     static_assert(util::is_pod<QueryRangeInfo>::value);
     static_assert(sizeof(QueryRangeInfo) == 0x40);
+
+    #if defined(ATMOSPHERE_OS_HORIZON)
     static_assert(sizeof(QueryRangeInfo) == sizeof(::FsRangeInfo));
+    #endif
 
     using FileQueryRangeInfo    = QueryRangeInfo;
     using StorageQueryRangeInfo = QueryRangeInfo;

libraries/libstratosphere/include/stratosphere/fs/fs_read_only_filesystem.hpp

@@ -30,7 +30,7 @@ namespace ams::fs {
             private:
                 std::unique_ptr<fsa::IFile> m_base_file;
             public:
-                explicit ReadOnlyFile(std::unique_ptr<fsa::IFile> &&f) : m_base_file(std::move(f)) { /* ... */ }
+                explicit ReadOnlyFile(std::unique_ptr<fsa::IFile> &&f) : m_base_file(std::move(f)) { AMS_ASSERT(m_base_file != nullptr); }
                 virtual ~ReadOnlyFile() { /* ... */ }
             private:
                 virtual Result DoRead(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) override final {
@@ -46,12 +46,17 @@ namespace ams::fs {
                 }
 
                 virtual Result DoWrite(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) override final {
-                    AMS_UNUSED(offset, buffer, size, option);
+                    bool need_append;
+                    R_TRY(this->DryWrite(std::addressof(need_append), offset, size, option, fs::OpenMode_Read));
+
+                    AMS_ASSERT(!need_append);
+
+                    AMS_UNUSED(buffer);
                     return fs::ResultUnsupportedOperationInReadOnlyFileA();
                 }
 
                 virtual Result DoSetSize(s64 size) override final {
-                    AMS_UNUSED(size);
+                    R_TRY(this->DrySetSize(size, fs::OpenMode_Read));
                     return fs::ResultUnsupportedOperationInReadOnlyFileA();
                 }
 
@@ -82,7 +87,7 @@ namespace ams::fs {
             explicit ReadOnlyFileSystemTemplate(T &&fs) : m_base_fs(std::move(fs)) { /* ... */ }
             virtual ~ReadOnlyFileSystemTemplate() { /* ... */ }
         private:
-            virtual Result DoOpenFile(std::unique_ptr<fsa::IFile> *out_file, const char *path, OpenMode mode) override final {
+            virtual Result DoOpenFile(std::unique_ptr<fsa::IFile> *out_file, const fs::Path &path, OpenMode mode) override final {
                 /* Only allow opening files with mode = read. */
                 R_UNLESS((mode & fs::OpenMode_All) == fs::OpenMode_Read, fs::ResultInvalidOpenMode());
 
@@ -96,11 +101,11 @@ namespace ams::fs {
                 return ResultSuccess();
             }
 
-            virtual Result DoOpenDirectory(std::unique_ptr<fsa::IDirectory> *out_dir, const char *path, OpenDirectoryMode mode) override final {
+            virtual Result DoOpenDirectory(std::unique_ptr<fsa::IDirectory> *out_dir, const fs::Path &path, OpenDirectoryMode mode) override final {
                 return m_base_fs->OpenDirectory(out_dir, path, mode);
             }
 
-            virtual Result DoGetEntryType(DirectoryEntryType *out, const char *path) override final {
+            virtual Result DoGetEntryType(DirectoryEntryType *out, const fs::Path &path) override final {
                 return m_base_fs->GetEntryType(out, path);
             }
 
@@ -108,52 +113,52 @@ namespace ams::fs {
                 return ResultSuccess();
             }
 
-            virtual Result DoCreateFile(const char *path, s64 size, int flags) override final {
+            virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override final {
                 AMS_UNUSED(path, size, flags);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoDeleteFile(const char *path) override final {
+            virtual Result DoDeleteFile(const fs::Path &path) override final {
                 AMS_UNUSED(path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoCreateDirectory(const char *path) override final {
+            virtual Result DoCreateDirectory(const fs::Path &path) override final {
                 AMS_UNUSED(path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoDeleteDirectory(const char *path) override final {
+            virtual Result DoDeleteDirectory(const fs::Path &path) override final {
                 AMS_UNUSED(path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoDeleteDirectoryRecursively(const char *path) override final {
+            virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override final {
                 AMS_UNUSED(path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoRenameFile(const char *old_path, const char *new_path) override final {
+            virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override final {
                 AMS_UNUSED(old_path, new_path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoRenameDirectory(const char *old_path, const char *new_path) override final {
+            virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override final {
                 AMS_UNUSED(old_path, new_path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoCleanDirectoryRecursively(const char *path) override final {
+            virtual Result DoCleanDirectoryRecursively(const fs::Path &path) override final {
                 AMS_UNUSED(path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateA();
             }
 
-            virtual Result DoGetFreeSpaceSize(s64 *out, const char *path) override final {
+            virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) override final {
                 AMS_UNUSED(out, path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateB();
             }
 
-            virtual Result DoGetTotalSpaceSize(s64 *out, const char *path) override final {
+            virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) override final {
                 AMS_UNUSED(out, path);
                 return fs::ResultUnsupportedOperationInReadOnlyFileSystemTemplateB();
             }

libraries/libstratosphere/include/stratosphere/fs/fs_remote_filesystem.hpp

@@ -20,11 +20,13 @@
 #include <stratosphere/fs/fsa/fs_idirectory.hpp>
 #include <stratosphere/fs/fsa/fs_ifilesystem.hpp>
 #include <stratosphere/fs/fs_query_range.hpp>
-#include <stratosphere/fs/fs_path_utils.hpp>
 
 namespace ams::fs {
 
+    #if defined(ATMOSPHERE_OS_HORIZON)
     class RemoteFile : public fsa::IFile, public impl::Newable {
+        NON_COPYABLE(RemoteFile);
+        NON_MOVEABLE(RemoteFile);
         private:
             ::FsFile m_base_file;
         public:
@@ -67,6 +69,8 @@ namespace ams::fs {
     };
 
     class RemoteDirectory : public fsa::IDirectory, public impl::Newable {
+        NON_COPYABLE(RemoteDirectory);
+        NON_MOVEABLE(RemoteDirectory);
         private:
             ::FsDir m_base_dir;
         public:
@@ -75,7 +79,8 @@ namespace ams::fs {
             virtual ~RemoteDirectory() { fsDirClose(std::addressof(m_base_dir)); }
         public:
             virtual Result DoRead(s64 *out_count, DirectoryEntry *out_entries, s64 max_entries) override final {
-                return fsDirRead(std::addressof(m_base_dir), out_count, max_entries, out_entries);
+                static_assert(sizeof(*out_entries) == sizeof(::FsDirectoryEntry));
+                return fsDirRead(std::addressof(m_base_dir), out_count, max_entries, reinterpret_cast<::FsDirectoryEntry *>(out_entries));
             }
 
             virtual Result DoGetEntryCount(s64 *out) override final {
@@ -88,6 +93,8 @@ namespace ams::fs {
     };
 
     class RemoteFileSystem : public fsa::IFileSystem, public impl::Newable {
+        NON_COPYABLE(RemoteFileSystem);
+        NON_MOVEABLE(RemoteFileSystem);
         private:
             ::FsFileSystem m_base_fs;
         public:
@@ -95,52 +102,51 @@ namespace ams::fs {
 
             virtual ~RemoteFileSystem() { fsFsClose(std::addressof(m_base_fs)); }
         private:
-            Result GetPathForServiceObject(fssrv::sf::Path *out_path, const char *path) {
+            Result GetPathForServiceObject(fssrv::sf::Path *out_path, const fs::Path &path) {
-                /* Copy and null terminate. */
+                /* Copy, ensuring length is in bounds. */
-                std::strncpy(out_path->str, path, sizeof(out_path->str) - 1);
+                const size_t len = util::Strlcpy<char>(out_path->str, path.GetString(), sizeof(out_path->str));
-                out_path->str[sizeof(out_path->str) - 1] = '\x00';
+                R_UNLESS(len < sizeof(out_path->str), fs::ResultTooLongPath());
 
                 /* Replace directory separators. */
-                fs::Replace(out_path->str, sizeof(out_path->str) - 1, StringTraits::AlternateDirectorySeparator, StringTraits::DirectorySeparator);
+                /* TODO: Is this still necessary? We originally had it to not break things on low firmware. */
+                #if defined(ATMOSPHERE_BOARD_NINTENDO_NX)
+                fs::Replace(out_path->str, sizeof(out_path->str) - 1, '\\', '/');
+                #endif
 
-                /* Get lengths. */
+                R_SUCCEED();
-                const auto skip_len = fs::GetWindowsPathSkipLength(path);
-                const auto rel_path = out_path->str + skip_len;
-                const auto max_len  = fs::EntryNameLengthMax - skip_len;
-                return VerifyPath(rel_path, max_len, max_len);
             }
         public:
-            virtual Result DoCreateFile(const char *path, s64 size, int flags) override final {
+            virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsCreateFile(std::addressof(m_base_fs), sf_path.str, size, flags);
             }
 
-            virtual Result DoDeleteFile(const char *path) override final {
+            virtual Result DoDeleteFile(const fs::Path &path) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsDeleteFile(std::addressof(m_base_fs), sf_path.str);
             }
 
-            virtual Result DoCreateDirectory(const char *path) override final {
+            virtual Result DoCreateDirectory(const fs::Path &path) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsCreateDirectory(std::addressof(m_base_fs), sf_path.str);
             }
 
-            virtual Result DoDeleteDirectory(const char *path) override final {
+            virtual Result DoDeleteDirectory(const fs::Path &path) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsDeleteDirectory(std::addressof(m_base_fs), sf_path.str);
             }
 
-            virtual Result DoDeleteDirectoryRecursively(const char *path) override final {
+            virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsDeleteDirectoryRecursively(std::addressof(m_base_fs), sf_path.str);
             }
 
-            virtual Result DoRenameFile(const char *old_path, const char *new_path) override final {
+            virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override final {
                 fssrv::sf::Path old_sf_path;
                 fssrv::sf::Path new_sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(old_sf_path), old_path));
@@ -148,7 +154,7 @@ namespace ams::fs {
                 return fsFsRenameFile(std::addressof(m_base_fs), old_sf_path.str, new_sf_path.str);
             }
 
-            virtual Result DoRenameDirectory(const char *old_path, const char *new_path) override final {
+            virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override final {
                 fssrv::sf::Path old_sf_path;
                 fssrv::sf::Path new_sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(old_sf_path), old_path));
@@ -156,7 +162,7 @@ namespace ams::fs {
                 return fsFsRenameDirectory(std::addressof(m_base_fs), old_sf_path.str, new_sf_path.str);
             }
 
-            virtual Result DoGetEntryType(DirectoryEntryType *out, const char *path) override final {
+            virtual Result DoGetEntryType(DirectoryEntryType *out, const fs::Path &path) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
 
@@ -164,7 +170,7 @@ namespace ams::fs {
                 return fsFsGetEntryType(std::addressof(m_base_fs), sf_path.str, reinterpret_cast<::FsDirEntryType *>(out));
             }
 
-            virtual Result DoOpenFile(std::unique_ptr<fsa::IFile> *out_file, const char *path, OpenMode mode) override final {
+            virtual Result DoOpenFile(std::unique_ptr<fsa::IFile> *out_file, const fs::Path &path, OpenMode mode) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
 
@@ -178,7 +184,7 @@ namespace ams::fs {
                 return ResultSuccess();
             }
 
-            virtual Result DoOpenDirectory(std::unique_ptr<fsa::IDirectory> *out_dir, const char *path, OpenDirectoryMode mode) override final {
+            virtual Result DoOpenDirectory(std::unique_ptr<fsa::IDirectory> *out_dir, const fs::Path &path, OpenDirectoryMode mode) override final {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
 
@@ -196,37 +202,37 @@ namespace ams::fs {
                 return fsFsCommit(std::addressof(m_base_fs));
             }
 
-
+            virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) {
-            virtual Result DoGetFreeSpaceSize(s64 *out, const char *path) {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsGetFreeSpace(std::addressof(m_base_fs), sf_path.str, out);
             }
 
-            virtual Result DoGetTotalSpaceSize(s64 *out, const char *path) {
+            virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsGetTotalSpace(std::addressof(m_base_fs), sf_path.str, out);
             }
 
-            virtual Result DoCleanDirectoryRecursively(const char *path) {
+            virtual Result DoCleanDirectoryRecursively(const fs::Path &path) {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsCleanDirectoryRecursively(std::addressof(m_base_fs), sf_path.str);
             }
 
-            virtual Result DoGetFileTimeStampRaw(FileTimeStampRaw *out, const char *path) {
+            virtual Result DoGetFileTimeStampRaw(FileTimeStampRaw *out, const fs::Path &path) {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 static_assert(sizeof(FileTimeStampRaw) == sizeof(::FsTimeStampRaw));
                 return fsFsGetFileTimeStampRaw(std::addressof(m_base_fs), sf_path.str, reinterpret_cast<::FsTimeStampRaw *>(out));
             }
 
-            virtual Result DoQueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const char *path) {
+            virtual Result DoQueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fsa::QueryId query, const fs::Path &path) {
                 fssrv::sf::Path sf_path;
                 R_TRY(GetPathForServiceObject(std::addressof(sf_path), path));
                 return fsFsQueryEntry(std::addressof(m_base_fs), dst, dst_size, src, src_size, sf_path.str, static_cast<FsFileSystemQueryId>(query));
             }
     };
+    #endif
 
 }

libraries/libstratosphere/include/stratosphere/fs/fs_remote_storage.hpp

@@ -20,35 +20,35 @@
 
 namespace ams::fs {
 
+    #if defined(ATMOSPHERE_OS_HORIZON)
     class RemoteStorage : public IStorage, public impl::Newable {
+        NON_COPYABLE(RemoteStorage);
+        NON_MOVEABLE(RemoteStorage);
         private:
-            std::unique_ptr<::FsStorage, impl::Deleter> m_base_storage;
+            ::FsStorage m_base_storage;
         public:
-            RemoteStorage(::FsStorage &s) {
+            RemoteStorage(::FsStorage &s) : m_base_storage(s) { /* ... */}
-                m_base_storage = impl::MakeUnique<::FsStorage>();
-                *m_base_storage = s;
-            }
 
-            virtual ~RemoteStorage() { fsStorageClose(m_base_storage.get()); }
+            virtual ~RemoteStorage() { fsStorageClose(std::addressof(m_base_storage)); }
         public:
             virtual Result Read(s64 offset, void *buffer, size_t size) override {
-                return fsStorageRead(m_base_storage.get(), offset, buffer, size);
+                return fsStorageRead(std::addressof(m_base_storage), offset, buffer, size);
             };
 
             virtual Result Write(s64 offset, const void *buffer, size_t size) override {
-                return fsStorageWrite(m_base_storage.get(), offset, buffer, size);
+                return fsStorageWrite(std::addressof(m_base_storage), offset, buffer, size);
             };
 
             virtual Result Flush() override {
-                return fsStorageFlush(m_base_storage.get());
+                return fsStorageFlush(std::addressof(m_base_storage));
             };
 
             virtual Result GetSize(s64 *out_size) override {
-                return fsStorageGetSize(m_base_storage.get(), out_size);
+                return fsStorageGetSize(std::addressof(m_base_storage), out_size);
             };
 
             virtual Result SetSize(s64 size) override {
-                return fsStorageSetSize(m_base_storage.get(), size);
+                return fsStorageSetSize(std::addressof(m_base_storage), size);
             };
 
             virtual Result OperateRange(void *dst, size_t dst_size, OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) override {
@@ -57,5 +57,6 @@ namespace ams::fs {
                 return fs::ResultUnsupportedOperation();
             };
     };
+    #endif
 
 }

libraries/libstratosphere/include/stratosphere/fs/fs_romfs_filesystem.hpp

@@ -51,20 +51,20 @@ namespace ams::fs {
             RomFileTable *GetRomFileTable();
             Result GetFileBaseOffset(s64 *out, const char *path);
         public:
-            virtual Result DoCreateFile(const char *path, s64 size, int flags) override;
+            virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override;
-            virtual Result DoDeleteFile(const char *path) override;
+            virtual Result DoDeleteFile(const fs::Path &path) override;
-            virtual Result DoCreateDirectory(const char *path) override;
+            virtual Result DoCreateDirectory(const fs::Path &path) override;
-            virtual Result DoDeleteDirectory(const char *path) override;
+            virtual Result DoDeleteDirectory(const fs::Path &path) override;
-            virtual Result DoDeleteDirectoryRecursively(const char *path) override;
+            virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override;
-            virtual Result DoRenameFile(const char *old_path, const char *new_path) override;
+            virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override;
-            virtual Result DoRenameDirectory(const char *old_path, const char *new_path) override;
+            virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override;
-            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const char *path) override;
+            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const fs::Path &path) override;
-            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const char *path, fs::OpenMode mode) override;
+            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const fs::Path &path, fs::OpenMode mode) override;
-            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const char *path, fs::OpenDirectoryMode mode) override;
+            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const fs::Path &path, fs::OpenDirectoryMode mode) override;
             virtual Result DoCommit() override;
-            virtual Result DoGetFreeSpaceSize(s64 *out, const char *path) override;
+            virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) override;
-            virtual Result DoGetTotalSpaceSize(s64 *out, const char *path) override;
+            virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) override;
-            virtual Result DoCleanDirectoryRecursively(const char *path) override;
+            virtual Result DoCleanDirectoryRecursively(const fs::Path &path) override;
 
             /* These aren't accessible as commands. */
             virtual Result DoCommitProvisionally(s64 counter) override;

libraries/libstratosphere/include/stratosphere/fs/fs_save_data_types.hpp

@@ -82,6 +82,20 @@ namespace ams::fs {
         SaveDataFlags_NeedsSecureDelete                                   = (1 << 3),
     };
 
+    enum class SaveDataMetaType : u8 {
+        None             = 0,
+        Thumbnail        = 1,
+        ExtensionContext = 2,
+    };
+
+    struct SaveDataMetaInfo {
+        u32 size;
+        SaveDataMetaType type;
+        u8 reserved[0xB];
+    };
+    static_assert(util::is_pod<SaveDataMetaInfo>::value);
+    static_assert(sizeof(SaveDataMetaInfo) == 0x10);
+
     struct SaveDataCreationInfo {
         s64 size;
         s64 journal_size;

libraries/libstratosphere/include/stratosphere/fs/fs_sd_card.hpp

@@ -20,6 +20,12 @@ namespace ams::fs {
 
     class IEventNotifier;
 
+    struct EncryptionSeed {
+        char value[0x10];
+    };
+    static_assert(util::is_pod<EncryptionSeed>::value);
+    static_assert(sizeof(EncryptionSeed) == 0x10);
+
     Result MountSdCard(const char *name);
 
     Result MountSdCardErrorReportDirectoryForAtmosphere(const char *name);

libraries/libstratosphere/include/stratosphere/fs/fs_shared_filesystem_holder.hpp

@@ -30,20 +30,20 @@ namespace ams::fs {
         public:
             SharedFileSystemHolder(std::shared_ptr<fsa::IFileSystem> f) : m_fs(std::move(f)) { /* ... */ }
         public:
-            virtual Result DoCreateFile(const char *path, s64 size, int flags) override { return m_fs->CreateFile(path, size, flags); }
+            virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) override { return m_fs->CreateFile(path, size, flags); }
-            virtual Result DoDeleteFile(const char *path) override { return m_fs->DeleteFile(path); }
+            virtual Result DoDeleteFile(const fs::Path &path) override { return m_fs->DeleteFile(path); }
-            virtual Result DoCreateDirectory(const char *path) override { return m_fs->CreateDirectory(path); }
+            virtual Result DoCreateDirectory(const fs::Path &path) override { return m_fs->CreateDirectory(path); }
-            virtual Result DoDeleteDirectory(const char *path) override { return m_fs->DeleteDirectory(path); }
+            virtual Result DoDeleteDirectory(const fs::Path &path) override { return m_fs->DeleteDirectory(path); }
-            virtual Result DoDeleteDirectoryRecursively(const char *path) override { return m_fs->DeleteDirectoryRecursively(path); }
+            virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) override { return m_fs->DeleteDirectoryRecursively(path); }
-            virtual Result DoRenameFile(const char *old_path, const char *new_path) override { return m_fs->RenameFile(old_path, new_path); }
+            virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) override { return m_fs->RenameFile(old_path, new_path); }
-            virtual Result DoRenameDirectory(const char *old_path, const char *new_path) override { return m_fs->RenameDirectory(old_path, new_path); }
+            virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) override { return m_fs->RenameDirectory(old_path, new_path); }
-            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const char *path) override { return m_fs->GetEntryType(out, path); }
+            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const fs::Path &path) override { return m_fs->GetEntryType(out, path); }
-            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const char *path, fs::OpenMode mode) override { return m_fs->OpenFile(out_file, path, mode); }
+            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const fs::Path &path, fs::OpenMode mode) override { return m_fs->OpenFile(out_file, path, mode); }
-            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const char *path, fs::OpenDirectoryMode mode) override { return m_fs->OpenDirectory(out_dir, path, mode); }
+            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const fs::Path &path, fs::OpenDirectoryMode mode) override { return m_fs->OpenDirectory(out_dir, path, mode); }
             virtual Result DoCommit() override { return m_fs->Commit(); }
-            virtual Result DoGetFreeSpaceSize(s64 *out, const char *path) override { return m_fs->GetFreeSpaceSize(out, path); }
+            virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) override { return m_fs->GetFreeSpaceSize(out, path); }
-            virtual Result DoGetTotalSpaceSize(s64 *out, const char *path) override { return m_fs->GetTotalSpaceSize(out, path); }
+            virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) override { return m_fs->GetTotalSpaceSize(out, path); }
-            virtual Result DoCleanDirectoryRecursively(const char *path) override { return m_fs->CleanDirectoryRecursively(path); }
+            virtual Result DoCleanDirectoryRecursively(const fs::Path &path) override { return m_fs->CleanDirectoryRecursively(path); }
 
             /* These aren't accessible as commands. */
             virtual Result DoCommitProvisionally(s64 counter) override { return m_fs->CommitProvisionally(counter); }

libraries/libstratosphere/include/stratosphere/fs/fsa/fs_idirectory.hpp

@@ -32,12 +32,12 @@ namespace ams::fs::fsa {
                 }
                 R_UNLESS(out_entries != nullptr, fs::ResultNullptrArgument());
                 R_UNLESS(max_entries > 0,        fs::ResultInvalidArgument());
-                return this->DoRead(out_count, out_entries, max_entries);
+                R_RETURN(this->DoRead(out_count, out_entries, max_entries));
             }
 
             Result GetEntryCount(s64 *out) {
                 R_UNLESS(out != nullptr, fs::ResultNullptrArgument());
-                return this->DoGetEntryCount(out);
+                R_RETURN(this->DoGetEntryCount(out));
             }
         public:
             /* TODO: This is a hack to allow the mitm API to work. Find a better way? */

libraries/libstratosphere/include/stratosphere/fs/fsa/fs_ifile.hpp

@@ -26,58 +26,69 @@ namespace ams::fs::fsa {
             virtual ~IFile() { /* ... */ }
 
             Result Read(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) {
+                /* Check that we have an output pointer. */
                 R_UNLESS(out != nullptr, fs::ResultNullptrArgument());
+
+                /* If we have nothing to read, just succeed. */
                 if (size == 0) {
                     *out = 0;
-                    return ResultSuccess();
+                    R_SUCCEED();
-                }
-                R_UNLESS(buffer != nullptr, fs::ResultNullptrArgument());
-                R_UNLESS(offset >= 0, fs::ResultOutOfRange());
-                const s64 signed_size = static_cast<s64>(size);
-                R_UNLESS(signed_size >= 0, fs::ResultOutOfRange());
-                R_UNLESS((std::numeric_limits<s64>::max() - offset) >= signed_size, fs::ResultOutOfRange());
-                return this->DoRead(out, offset, buffer, size, option);
                 }
 
-            Result Read(size_t *out, s64 offset, void *buffer, size_t size) {
+                /* Check that the read is valid. */
-                return this->Read(out, offset, buffer, size, ReadOption::None);
+                R_UNLESS(buffer != nullptr,                        fs::ResultNullptrArgument());
+                R_UNLESS(offset >= 0,                              fs::ResultOutOfRange());
+                R_UNLESS(util::IsIntValueRepresentable<s64>(size), fs::ResultOutOfRange());
+
+                const s64 signed_size = static_cast<s64>(size);
+                R_UNLESS((std::numeric_limits<s64>::max() - offset) >= signed_size, fs::ResultOutOfRange());
+
+                /* Do the read. */
+                R_RETURN(this->DoRead(out, offset, buffer, size, option));
             }
 
+            ALWAYS_INLINE Result Read(size_t *out, s64 offset, void *buffer, size_t size) { R_RETURN(this->Read(out, offset, buffer, size, ReadOption::None)); }
+
             Result GetSize(s64 *out) {
                 R_UNLESS(out != nullptr, fs::ResultNullptrArgument());
-                return this->DoGetSize(out);
+                R_RETURN(this->DoGetSize(out));
             }
 
             Result Flush() {
-                return this->DoFlush();
+                R_RETURN(this->DoFlush());
             }
 
             Result Write(s64 offset, const void *buffer, size_t size, const fs::WriteOption &option) {
+                /* Handle the zero-size case. */
                 if (size == 0) {
                     if (option.HasFlushFlag()) {
                         R_TRY(this->Flush());
                     }
-                    return ResultSuccess();
+                    R_SUCCEED();
                 }
+
+                /* Check the write is valid. */
                 R_UNLESS(buffer != nullptr,                        fs::ResultNullptrArgument());
                 R_UNLESS(offset >= 0,                              fs::ResultOutOfRange());
+                R_UNLESS(util::IsIntValueRepresentable<s64>(size), fs::ResultOutOfRange());
+
                 const s64 signed_size = static_cast<s64>(size);
-                R_UNLESS(signed_size >= 0, fs::ResultOutOfRange());
                 R_UNLESS((std::numeric_limits<s64>::max() - offset) >= signed_size, fs::ResultOutOfRange());
-                return this->DoWrite(offset, buffer, size, option);
+
+                R_RETURN(this->DoWrite(offset, buffer, size, option));
             }
 
             Result SetSize(s64 size) {
                 R_UNLESS(size >= 0, fs::ResultOutOfRange());
-                return this->DoSetSize(size);
+                R_RETURN(this->DoSetSize(size));
             }
 
             Result OperateRange(void *dst, size_t dst_size, fs::OperationId op_id, s64 offset, s64 size, const void *src, size_t src_size) {
-                return this->DoOperateRange(dst, dst_size, op_id, offset, size, src, src_size);
+                R_RETURN(this->DoOperateRange(dst, dst_size, op_id, offset, size, src, src_size));
             }
 
             Result OperateRange(fs::OperationId op_id, s64 offset, s64 size) {
-                return this->DoOperateRange(nullptr, 0, op_id, offset, size, nullptr, 0);
+                R_RETURN(this->DoOperateRange(nullptr, 0, op_id, offset, size, nullptr, 0));
             }
         public:
             /* TODO: This is a hack to allow the mitm API to work. Find a better way? */
@@ -91,21 +102,19 @@ namespace ams::fs::fsa {
 
                 /* Get the file size, and validate our offset. */
                 s64 file_size = 0;
-                R_TRY(this->GetSize(&file_size));
+                R_TRY(this->DoGetSize(std::addressof(file_size)));
                 R_UNLESS(offset <= file_size, fs::ResultOutOfRange());
 
                 *out = static_cast<size_t>(std::min(file_size - offset, static_cast<s64>(size)));
-                return ResultSuccess();
+                R_SUCCEED();
             }
 
             Result DrySetSize(s64 size, fs::OpenMode open_mode) {
-                /* Check that we can write. */
-                R_UNLESS((open_mode & OpenMode_Write) != 0, fs::ResultWriteNotPermitted());
-
-                AMS_ASSERT(size >= 0);
                 AMS_UNUSED(size);
 
-                return ResultSuccess();
+                /* Check that we can write. */
+                R_UNLESS((open_mode & OpenMode_Write) != 0, fs::ResultWriteNotPermitted());
+                R_SUCCEED();
             }
 
             Result DryWrite(bool *out_append, s64 offset, size_t size, const fs::WriteOption &option, fs::OpenMode open_mode) {
@@ -116,17 +125,16 @@ namespace ams::fs::fsa {
 
                 /* Get the file size. */
                 s64 file_size = 0;
-                R_TRY(this->GetSize(&file_size));
+                R_TRY(this->DoGetSize(&file_size));
 
                 /* Determine if we need to append. */
+                *out_append = false;
                 if (file_size < offset + static_cast<s64>(size)) {
                     R_UNLESS((open_mode & OpenMode_AllowAppend) != 0, fs::ResultFileExtensionWithoutOpenModeAllowAppend());
                     *out_append = true;
-                } else {
-                    *out_append = false;
                 }
 
-                return ResultSuccess();
+                R_SUCCEED();
             }
         private:
             virtual Result DoRead(size_t *out, s64 offset, void *buffer, size_t size, const fs::ReadOption &option) = 0;

libraries/libstratosphere/include/stratosphere/fs/fsa/fs_ifilesystem.hpp

@@ -18,6 +18,7 @@
 #include <stratosphere/fs/fs_common.hpp>
 #include <stratosphere/fs/fs_filesystem.hpp>
 #include <stratosphere/fs/fs_filesystem_for_debug.hpp>
+#include <stratosphere/fs/fs_path.hpp>
 
 namespace ams::fs::fsa {
 
@@ -26,172 +27,156 @@ namespace ams::fs::fsa {
 
     enum class QueryId {
         SetConcatenationFileAttribute        = 0,
+        UpdateMac                            = 1,
         IsSignedSystemPartitionOnSdCardValid = 2,
+        QueryUnpreparedFileInformation       = 3,
     };
 
     class IFileSystem {
         public:
             virtual ~IFileSystem() { /* ... */ }
 
-            Result CreateFile(const char *path, s64 size, int option) {
+            Result CreateFile(const fs::Path &path, s64 size, int option) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
                 R_UNLESS(size >= 0, fs::ResultOutOfRange());
-                return this->DoCreateFile(path, size, option);
+                R_RETURN(this->DoCreateFile(path, size, option));
             }
 
-            Result CreateFile(const char *path, s64 size) {
+            Result CreateFile(const fs::Path &path, s64 size) {
-                return this->CreateFile(path, size, 0);
+                R_RETURN(this->CreateFile(path, size, fs::CreateOption_None));
             }
 
-            Result DeleteFile(const char *path) {
+            Result DeleteFile(const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoDeleteFile(path));
-                return this->DoDeleteFile(path);
             }
 
-            Result CreateDirectory(const char *path) {
+            Result CreateDirectory(const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoCreateDirectory(path));
-                return this->DoCreateDirectory(path);
             }
 
-            Result DeleteDirectory(const char *path) {
+            Result DeleteDirectory(const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoDeleteDirectory(path));
-                return this->DoDeleteDirectory(path);
             }
 
-            Result DeleteDirectoryRecursively(const char *path) {
+            Result DeleteDirectoryRecursively(const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoDeleteDirectoryRecursively(path));
-                return this->DoDeleteDirectoryRecursively(path);
             }
 
-            Result RenameFile(const char *old_path, const char *new_path) {
+            Result RenameFile(const fs::Path &old_path, const fs::Path &new_path) {
-                R_UNLESS(old_path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoRenameFile(old_path, new_path));
-                R_UNLESS(new_path != nullptr, fs::ResultInvalidPath());
-                return this->DoRenameFile(old_path, new_path);
             }
 
-            Result RenameDirectory(const char *old_path, const char *new_path) {
+            Result RenameDirectory(const fs::Path &old_path, const fs::Path &new_path) {
-                R_UNLESS(old_path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoRenameDirectory(old_path, new_path));
-                R_UNLESS(new_path != nullptr, fs::ResultInvalidPath());
-                return this->DoRenameDirectory(old_path, new_path);
             }
 
-            Result GetEntryType(DirectoryEntryType *out, const char *path) {
+            Result GetEntryType(DirectoryEntryType *out, const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoGetEntryType(out, path));
-                R_UNLESS(out != nullptr,  fs::ResultNullptrArgument());
-                return this->DoGetEntryType(out, path);
             }
 
-            Result OpenFile(std::unique_ptr<IFile> *out_file, const char *path, OpenMode mode) {
+            Result OpenFile(std::unique_ptr<IFile> *out_file, const fs::Path &path, OpenMode mode) {
-                R_UNLESS(path != nullptr,                  fs::ResultInvalidPath());
                 R_UNLESS(out_file != nullptr,              fs::ResultNullptrArgument());
                 R_UNLESS((mode & OpenMode_ReadWrite) != 0, fs::ResultInvalidOpenMode());
                 R_UNLESS((mode & ~OpenMode_All) == 0,      fs::ResultInvalidOpenMode());
-                return this->DoOpenFile(out_file, path, mode);
+                R_RETURN(this->DoOpenFile(out_file, path, mode));
             }
 
-            Result OpenDirectory(std::unique_ptr<IDirectory> *out_dir, const char *path, OpenDirectoryMode mode) {
+            Result OpenDirectory(std::unique_ptr<IDirectory> *out_dir, const fs::Path &path, OpenDirectoryMode mode) {
-                R_UNLESS(path != nullptr,                                                               fs::ResultInvalidPath());
                 R_UNLESS(out_dir != nullptr,                                                            fs::ResultNullptrArgument());
                 R_UNLESS((mode &  OpenDirectoryMode_All) != 0,                                          fs::ResultInvalidOpenMode());
                 R_UNLESS((mode & ~(OpenDirectoryMode_All | OpenDirectoryMode_NotRequireFileSize)) == 0, fs::ResultInvalidOpenMode());
-                return this->DoOpenDirectory(out_dir, path, mode);
+                R_RETURN(this->DoOpenDirectory(out_dir, path, mode));
             }
 
             Result Commit() {
-                return this->DoCommit();
+                R_RETURN(this->DoCommit());
             }
 
-            Result GetFreeSpaceSize(s64 *out, const char *path) {
+            Result GetFreeSpaceSize(s64 *out, const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
                 R_UNLESS(out != nullptr,  fs::ResultNullptrArgument());
-                return this->DoGetFreeSpaceSize(out, path);
+                R_RETURN(this->DoGetFreeSpaceSize(out, path));
             }
 
-            Result GetTotalSpaceSize(s64 *out, const char *path) {
+            Result GetTotalSpaceSize(s64 *out, const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
                 R_UNLESS(out != nullptr,  fs::ResultNullptrArgument());
-                return this->DoGetTotalSpaceSize(out, path);
+                R_RETURN(this->DoGetTotalSpaceSize(out, path));
             }
 
-            Result CleanDirectoryRecursively(const char *path) {
+            Result CleanDirectoryRecursively(const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoCleanDirectoryRecursively(path));
-                return this->DoCleanDirectoryRecursively(path);
             }
 
-            Result GetFileTimeStampRaw(FileTimeStampRaw *out, const char *path) {
+            Result GetFileTimeStampRaw(FileTimeStampRaw *out, const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
                 R_UNLESS(out != nullptr,  fs::ResultNullptrArgument());
-                return this->DoGetFileTimeStampRaw(out, path);
+                R_RETURN(this->DoGetFileTimeStampRaw(out, path));
             }
 
-            Result QueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, QueryId query, const char *path) {
+            Result QueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, QueryId query, const fs::Path &path) {
-                R_UNLESS(path != nullptr, fs::ResultInvalidPath());
+                R_RETURN(this->DoQueryEntry(dst, dst_size, src, src_size, query, path));
-                return this->DoQueryEntry(dst, dst_size, src, src_size, query, path);
             }
 
             /* These aren't accessible as commands. */
 
             Result CommitProvisionally(s64 counter) {
-                return this->DoCommitProvisionally(counter);
+                R_RETURN(this->DoCommitProvisionally(counter));
             }
 
             Result Rollback() {
-                return this->DoRollback();
+                R_RETURN(this->DoRollback());
             }
 
             Result Flush() {
-                return this->DoFlush();
+                R_RETURN(this->DoFlush());
             }
 
         protected:
             /* ...? */
         private:
-            virtual Result DoCreateFile(const char *path, s64 size, int flags) = 0;
+            virtual Result DoCreateFile(const fs::Path &path, s64 size, int flags) = 0;
-            virtual Result DoDeleteFile(const char *path) = 0;
+            virtual Result DoDeleteFile(const fs::Path &path) = 0;
-            virtual Result DoCreateDirectory(const char *path) = 0;
+            virtual Result DoCreateDirectory(const fs::Path &path) = 0;
-            virtual Result DoDeleteDirectory(const char *path) = 0;
+            virtual Result DoDeleteDirectory(const fs::Path &path) = 0;
-            virtual Result DoDeleteDirectoryRecursively(const char *path) = 0;
+            virtual Result DoDeleteDirectoryRecursively(const fs::Path &path) = 0;
-            virtual Result DoRenameFile(const char *old_path, const char *new_path) = 0;
+            virtual Result DoRenameFile(const fs::Path &old_path, const fs::Path &new_path) = 0;
-            virtual Result DoRenameDirectory(const char *old_path, const char *new_path) = 0;
+            virtual Result DoRenameDirectory(const fs::Path &old_path, const fs::Path &new_path) = 0;
-            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const char *path) = 0;
+            virtual Result DoGetEntryType(fs::DirectoryEntryType *out, const fs::Path &path) = 0;
-            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const char *path, fs::OpenMode mode) = 0;
+            virtual Result DoOpenFile(std::unique_ptr<fs::fsa::IFile> *out_file, const fs::Path &path, fs::OpenMode mode) = 0;
-            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const char *path, fs::OpenDirectoryMode mode) = 0;
+            virtual Result DoOpenDirectory(std::unique_ptr<fs::fsa::IDirectory> *out_dir, const fs::Path &path, fs::OpenDirectoryMode mode) = 0;
             virtual Result DoCommit() = 0;
 
-            virtual Result DoGetFreeSpaceSize(s64 *out, const char *path) {
+            virtual Result DoGetFreeSpaceSize(s64 *out, const fs::Path &path) {
                 AMS_UNUSED(out, path);
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
-            virtual Result DoGetTotalSpaceSize(s64 *out, const char *path) {
+            virtual Result DoGetTotalSpaceSize(s64 *out, const fs::Path &path) {
                 AMS_UNUSED(out, path);
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
-            virtual Result DoCleanDirectoryRecursively(const char *path) = 0;
+            virtual Result DoCleanDirectoryRecursively(const fs::Path &path) = 0;
 
-            virtual Result DoGetFileTimeStampRaw(fs::FileTimeStampRaw *out, const char *path) {
+            virtual Result DoGetFileTimeStampRaw(fs::FileTimeStampRaw *out, const fs::Path &path) {
                 AMS_UNUSED(out, path);
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
-            virtual Result DoQueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fs::fsa::QueryId query, const char *path) {
+            virtual Result DoQueryEntry(char *dst, size_t dst_size, const char *src, size_t src_size, fs::fsa::QueryId query, const fs::Path &path) {
                 AMS_UNUSED(dst, dst_size, src, src_size, query, path);
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
             /* These aren't accessible as commands. */
             virtual Result DoCommitProvisionally(s64 counter) {
                 AMS_UNUSED(counter);
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
             virtual Result DoRollback() {
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
 
             virtual Result DoFlush() {
-                return fs::ResultNotImplemented();
+                R_THROW(fs::ResultNotImplemented());
             }
     };
 

libraries/libstratosphere/include/stratosphere/fs/impl/fs_access_log_impl.hpp

@@ -83,6 +83,8 @@ namespace ams::fs::impl {
         }
     }
 
+    static_assert(sizeof(size_t) == sizeof(u64));
+
 }
 
 /* Access log result name. */
@@ -92,8 +94,9 @@ namespace ams::fs::impl {
 
 /* Access log components. */
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SIZE                   ", size: %" PRId64 ""
-#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_READ_SIZE             ", read_size: %zu"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_READ_SIZE              ", read_size: %" PRIuZ ""
-#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_OFFSET_AND_SIZE       ", offset: %" PRId64 ", size: %zu"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_QUERY_SIZE             ", read_size: %" PRIuZ ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_OFFSET_AND_SIZE        ", offset: %" PRId64 ", size: %" PRIuZ ""
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_THREAD_ID              ", thread_id: %" PRIu64 ""
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT                  ", name: \"%s\""
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_ENTRY_COUNT            ", entry_count: %" PRId64 ""
@@ -104,6 +107,27 @@ namespace ams::fs::impl {
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH_AND_OPEN_MODE     ", path: \"%s\", open_mode: 0x%" PRIX32 ""
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_RENAME                 ", path: \"%s\", new_path: \"%s\""
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_DIRECTORY_ENTRY_TYPE   ", entry_type: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_TYPE           ", content_type: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_OPTION      ", mount_host_option: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_ROOT_PATH              ", root_path: %s"
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_APPLICATION_ID         ", applicationid: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_BIS_PARTITION_ID       ", bispartitionid: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_STORAGE_ID     ", contentstorageid: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SYSTEM_DATA_ID         ", systemdataid: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_DATA_ID                ", dataid: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_GAME_CARD_HANDLE       ", gamecard_handle: 0x%" PRIX32 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_GAME_CARD_PARTITION    ", gamecard_partition: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_IMAGE_DIRECTORY_ID     ", imagedirectoryid: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_PROGRAM_ID             ", programid: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID           ", savedataid: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID     ", savedataspaceid: %s"
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_OWNER_ID     ", save_data_owner_id: 0x%" PRIx64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_USER_ID                ", userid: 0x%016" PRIx64 "%016" PRIx64 ""
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_FLAGS        ", save_data_flags: 0x%08" PRIX32 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_JOURNAL_SIZE ", save_data_journal_size: %" PRId64 ""
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SIZE         ", save_data_size: %" PRId64 ""
 
 /* Access log formats. */
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_NONE ""
@@ -130,62 +154,135 @@ namespace ams::fs::impl {
 #define AMS_FS_IMPL_ACCESS_LOG_FORMAT_GET_SPACE_SIZE(__OUT_SIZE__, __NAME__) \
     AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_SIZE, __NAME__, AMS_FS_IMPL_ACCESS_LOG_DEREFERENCE_OUT_VALUE(__OUT_SIZE__)
 
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_APPLICATION_PACKAGE(__NAME__, __PATH__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH, (__NAME__), (__PATH__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_BIS(__NAME__, __ID__, __PATH__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_BIS_PARTITION_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH, (__NAME__), ::ams::fs::impl::IdString().ToString(__ID__), (__PATH__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CODE(__NAME__, __PATH__, __ID__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH AMS_FS_IMPL_ACCESS_LOG_FORMAT_PROGRAM_ID, (__NAME__), (__PATH__), (__ID__).value
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CONTENT_PATH(__NAME__, __PATH__, __TYPE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_TYPE, (__NAME__), (__PATH__), ::ams::fs::impl::IdString().ToString(__TYPE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CONTENT_PROGRAM_ID(__NAME__, __ID__, __TYPE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PROGRAM_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_TYPE, (__NAME__), (__ID__), ::ams::fs::impl::IdString().ToString(__TYPE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CONTENT_PATH_AND_PROGRAM_ID(__NAME__, __PATH__, __ID__, __TYPE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH AMS_FS_IMPL_ACCESS_LOG_FORMAT_PROGRAM_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_TYPE, (__NAME__), (__PATH__), (__ID__).value, ::ams::fs::impl::IdString().ToString(__TYPE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CONTENT_PATH_AND_DATA_ID(__NAME__, __PATH__, __ID__, __TYPE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_PATH AMS_FS_IMPL_ACCESS_LOG_FORMAT_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_TYPE, (__NAME__), (__PATH__), (__ID__).value, ::ams::fs::impl::IdString().ToString(__TYPE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_CONTENT_STORAGE(__NAME__, __ID__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_CONTENT_STORAGE_ID, (__NAME__), ::ams::fs::impl::IdString().ToString(__ID__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_DEVICE_SAVE_DATA_APPLICATION_ID(__NAME__, __ID__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_APPLICATION_ID, (__NAME__), (__ID__).value
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_GAME_CARD_PARTITION(__NAME__, __GCHANDLE__, __PARTITION__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_GAME_CARD_HANDLE AMS_FS_IMPL_ACCESS_LOG_FORMAT_GAME_CARD_PARTITION, (__NAME__), __GCHANDLE__, ::ams::fs::impl::IdString().ToString(__PARTITION__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_ROOT() \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT, (AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_ROOT_WITH_OPTION(__OPTION__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_OPTION, (AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME), ::ams::fs::impl::IdString().ToString(__OPTION__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST(__NAME__, __ROOT_PATH__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_ROOT_PATH, (__NAME__), (__ROOT_PATH__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_WITH_OPTION(__NAME__, __ROOT_PATH__, __OPTION__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_ROOT_PATH AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_HOST_OPTION, (__NAME__), (__ROOT_PATH__), ::ams::fs::impl::IdString().ToString(__OPTION__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_IMAGE_DIRECTORY(__NAME__, __ID__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_IMAGE_DIRECTORY_ID, (__NAME__), ::ams::fs::impl::IdString().ToString(__ID__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_SYSTEM_DATA(__NAME__, __ID__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_SYSTEM_DATA_ID, (__NAME__), (__ID__).value
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT_SYSTEM_SAVE_DATA(__NAME__, __SPACE__, __SAVE__, __USER__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_MOUNT AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_USER_ID, \
+    (__NAME__), ::ams::fs::impl::IdString().ToString(__SPACE__), (__SAVE__), (__USER__).data[0], (__USER__).data[1]
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_CREATE_SYSTEM_SAVE_DATA(__SPACE__, __SAVE__, __USER__, __OWNER__, __SIZE__, __JOURNAL_SIZE__, __FLAGS__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_USER_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_OWNER_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SIZE AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_JOURNAL_SIZE AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_FLAGS, \
+    ::ams::fs::impl::IdString().ToString(__SPACE__), (__SAVE__), (__USER__).data[0], (__USER__).data[1], (__OWNER__), (__SIZE__), (__JOURNAL_SIZE__), (__FLAGS__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_DELETE_SAVE_DATA(__SPACE__, __SAVE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID, \
+    ::ams::fs::impl::IdString().ToString(__SPACE__), (__SAVE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_DELETE_SYSTEM_SAVE_DATA(__SPACE__, __SAVE__, __USER__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_USER_ID, \
+    ::ams::fs::impl::IdString().ToString(__SPACE__), (__SAVE__), (__USER__).data[0], (__USER__).data[1]
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_EXTEND_SAVE_DATA(__SPACE__, __SAVE__, __SIZE__, __JOURNAL_SIZE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SPACE_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_SIZE AMS_FS_IMPL_ACCESS_LOG_FORMAT_SAVE_DATA_JOURNAL_SIZE, \
+    ::ams::fs::impl::IdString().ToString(__SPACE__), (__SAVE__), (__SIZE__), (__JOURNAL_SIZE__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FORMAT_QUERY_MOUNT_SYSTEM_DATA_CACHE_SIZE(__ID__, __SIZE__) \
+    AMS_FS_IMPL_ACCESS_LOG_FORMAT_SYSTEM_DATA_ID AMS_FS_IMPL_ACCESS_LOG_FORMAT_QUERY_SIZE, (__ID__).value, AMS_FS_IMPL_ACCESS_LOG_DEREFERENCE_OUT_VALUE(__SIZE__)
+
 /* Access log invocation lambdas. */
 #define AMS_FS_IMPL_ACCESS_LOG_IMPL(__EXPR__, __HANDLE__, __ENABLED__, __NAME__, ...)                                                                       \
-    [&](const char *name) -> Result {                                                                                                  \
+    [&](const char *__fs_func_name_) -> Result {                                                                                                            \
         if (!(__ENABLED__)) {                                                                                                                               \
-            return (__EXPR__);                                                                                               \
+            R_RETURN(__EXPR__);                                                                                                                             \
         } else {                                                                                                                                            \
-            const ::ams::os::Tick start = ::ams::os::GetSystemTick();                                                        \
+            const ::ams::os::Tick __fs_start_tick = ::ams::os::GetSystemTick();                                                                             \
             const auto AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME = (__EXPR__);                                                                                     \
-            const ::ams::os::Tick end = ::ams::os::GetSystemTick();                                                          \
+            const ::ams::os::Tick __fs_end_tick = ::ams::os::GetSystemTick();                                                                               \
-            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, start, end, name, __HANDLE__, __VA_ARGS__); \
+            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __fs_start_tick, __fs_end_tick, __fs_func_name_, __HANDLE__, __VA_ARGS__); \
-            return AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME;                                                                       \
+            R_RETURN( AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME );                                                                                                 \
         }                                                                                                                                                   \
     }(__NAME__)
 
 #define AMS_FS_IMPL_ACCESS_LOG_WITH_PRIORITY_IMPL(__EXPR__, __PRIORITY__, __HANDLE__, __ENABLED__, __NAME__, ...)                                                         \
-    [&](const char *name) -> Result {                                                                                                                 \
+    [&](const char *__fs_func_name_) -> Result {                                                                                                                          \
         if (!(__ENABLED__)) {                                                                                                                                             \
-            return (__EXPR__);                                                                                                              \
+            R_RETURN(__EXPR__);                                                                                                                                           \
         } else {                                                                                                                                                          \
-            const ::ams::os::Tick start = ::ams::os::GetSystemTick();                                                                       \
+            const ::ams::os::Tick __fs_start_tick = ::ams::os::GetSystemTick();                                                                                           \
             const auto AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME = (__EXPR__);                                                                                                   \
-            const ::ams::os::Tick end = ::ams::os::GetSystemTick();                                                                         \
+            const ::ams::os::Tick __fs_end_tick = ::ams::os::GetSystemTick();                                                                                             \
-            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __PRIORITY__, start, end, name, __HANDLE__, __VA_ARGS__);  \
+            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __PRIORITY__, __fs_start_tick, __fs_end_tick, __fs_func_name_, __HANDLE__, __VA_ARGS__); \
-            return AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME;                                                                                      \
+            R_RETURN( AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME );                                                                                                               \
         }                                                                                                                                                                 \
     }(__NAME__)
 
 #define AMS_FS_IMPL_ACCESS_LOG_EXPLICIT_IMPL(__RESULT__, __START__, __END__, __HANDLE__, __ENABLED__, __NAME__, ...)                            \
-    [&](const char *name) -> Result {                                                                                                          \
+    [&](const char *__fs_func_name_) -> Result {                                                                                                \
         if (!(__ENABLED__)) {                                                                                                                   \
-            return __RESULT__;                                                                                                       \
+            R_RETURN(__RESULT__);                                                                                                               \
         } else {                                                                                                                                \
             const auto AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME = (__RESULT__);                                                                       \
-            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __START__, __END__, name, __HANDLE__, __VA_ARGS__); \
+            ::ams::fs::impl::OutputAccessLog(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __START__, __END__, __fs_func_name_, __HANDLE__, __VA_ARGS__); \
-            return AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME;                                                                               \
+            R_RETURN( AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME );                                                                                     \
         }                                                                                                                                       \
     }(__NAME__)
 
 #define AMS_FS_IMPL_ACCESS_LOG_UNLESS_R_SUCCEEDED_IMPL(__EXPR__, __ENABLED__, __NAME__, ...)                                                                                \
-    [&](const char *name) -> Result {                                                                                                                  \
+    [&](const char *__fs_func_name_) -> Result {                                                                                                                            \
         if (!(__ENABLED__)) {                                                                                                                                               \
-            return (__EXPR__);                                                                                                               \
+            R_RETURN(__EXPR__);                                                                                                                                             \
         } else {                                                                                                                                                            \
-            const ::ams::os::Tick start = ::ams::os::GetSystemTick();                                                                        \
+            const ::ams::os::Tick __fs_start_tick = ::ams::os::GetSystemTick();                                                                                             \
             const auto AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME = (__EXPR__);                                                                                                     \
-            const ::ams::os::Tick end = ::ams::os::GetSystemTick();                                                                          \
+            const ::ams::os::Tick __fs_end_tick = ::ams::os::GetSystemTick();                                                                                               \
-            ::ams::fs::impl::OutputAccessLogUnlessResultSuccess(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, start, end, name, nullptr, __VA_ARGS__); \
+            ::ams::fs::impl::OutputAccessLogUnlessResultSuccess(AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME, __fs_start_tick, __fs_end_tick, __fs_func_name_, nullptr, __VA_ARGS__); \
-            return AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME;                                                                                       \
+            R_RETURN( AMS_FS_IMPL_ACCESS_LOG_RESULT_NAME );                                                                                                                 \
         }                                                                                                                                                                   \
     }(__NAME__)
 
-
 /* Access log api. */
 #define AMS_FS_IMPL_ACCESS_LOG(__EXPR__, __HANDLE__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), __HANDLE__, ::ams::fs::impl::IsEnabledAccessLog() && ::ams::fs::impl::IsEnabledHandleAccessLog(__HANDLE__), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
 
+#define AMS_FS_IMPL_ACCESS_LOG_SYSTEM(__EXPR__, __HANDLE__, ...) \
+    AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), __HANDLE__, ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_System) && ::ams::fs::impl::IsEnabledHandleAccessLog(__HANDLE__), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
+
 #define AMS_FS_IMPL_ACCESS_LOG_WITH_NAME(__EXPR__, __HANDLE__, __NAME__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), __HANDLE__, ::ams::fs::impl::IsEnabledAccessLog() && ::ams::fs::impl::IsEnabledHandleAccessLog(__HANDLE__), __NAME__, __VA_ARGS__)
 
@@ -195,6 +292,37 @@ namespace ams::fs::impl {
 #define AMS_FS_IMPL_ACCESS_LOG_UNLESS_R_SUCCEEDED(__EXPR__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_UNLESS_R_SUCCEEDED_IMPL((__EXPR__), ::ams::fs::impl::IsEnabledAccessLog(), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
 
+/* FS Accessor logging. */
+#define AMS_FS_IMPL_ACCESS_LOG_FS_ACCESSOR_ENABLE_IMPL(__NAME__, __ENABLED__) \
+    do {                                                                          \
+        if (static_cast<bool>(__ENABLED__)) {                                     \
+            ::ams::fs::impl::EnableFileSystemAccessorAccessLog((__NAME__));       \
+        }                                                                         \
+    } while (false)
+
+#define AMS_FS_IMPL_ACCESS_LOG_FS_ACCESSOR_ENABLE(__NAME__) \
+    AMS_FS_IMPL_ACCESS_LOG_FS_ACCESSOR_ENABLE_IMPL((__NAME__), ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_Application))
+
+// DEBUG
+#define AMS_FS_FORCE_ENABLE_SYSTEM_MOUNT_ACCESS_LOG
+
+/* System access log api. */
+#if defined(AMS_BUILD_FOR_DEBUGGING) || defined(AMS_BUILD_FOR_AUDITING) || defined(AMS_FS_FORCE_ENABLE_SYSTEM_MOUNT_ACCESS_LOG)
+
+#define AMS_FS_IMPL_ACCESS_LOG_SYSTEM_MOUNT(__EXPR__, __NAME__, ...) \
+    AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), nullptr, ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_System), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_SYSTEM_FS_ACCESSOR_ENABLE(__NAME__) \
+    AMS_FS_IMPL_ACCESS_LOG_FS_ACCESSOR_ENABLE_IMPL((__NAME__), ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_System))
+
+#else
+
+#define AMS_FS_IMPL_ACCESS_LOG_SYSTEM_MOUNT(__EXPR__, __NAME__, ...) (__EXPR__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_SYSTEM_FS_ACCESSOR_ENABLE(__NAME__) static_cast<void>(0)
+
+#endif
+
 /* Specific utilities. */
 #define AMS_FS_IMPL_ACCESS_LOG_FILESYSTEM(__EXPR__, __HANDLE__, __FILESYSTEM__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), __HANDLE__, ::ams::fs::impl::IsEnabledAccessLog() && (__FILESYSTEM__)->IsEnabledAccessLog(), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
@@ -202,5 +330,11 @@ namespace ams::fs::impl {
 #define AMS_FS_IMPL_ACCESS_LOG_FILESYSTEM_WITH_NAME(__EXPR__, __HANDLE__, __FILESYSTEM__, __NAME__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), __HANDLE__, ::ams::fs::impl::IsEnabledAccessLog() && (__FILESYSTEM__)->IsEnabledAccessLog(), __NAME__, __VA_ARGS__)
 
+#define AMS_FS_IMPL_ACCESS_LOG_MOUNT(__EXPR__, __NAME__, ...) \
+    AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), nullptr, ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_Application), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
+
+#define AMS_FS_IMPL_ACCESS_LOG_MOUNT_UNLESS_R_SUCCEEDED(__EXPR__, __NAME__, ...) \
+    AMS_FS_IMPL_ACCESS_LOG_UNLESS_R_SUCCEEDED_IMPL((__EXPR__), ::ams::fs::impl::IsEnabledAccessLog(::ams::fs::impl::AccessLogTarget_Application), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)
+
 #define AMS_FS_IMPL_ACCESS_LOG_UNMOUNT(__EXPR__, __MOUNT_NAME__, ...) \
     AMS_FS_IMPL_ACCESS_LOG_IMPL((__EXPR__), nullptr, ::ams::fs::impl::IsEnabledAccessLog() && ::ams::fs::impl::IsEnabledFileSystemAccessorAccessLog(__MOUNT_NAME__), AMS_CURRENT_FUNCTION_NAME, __VA_ARGS__)

libraries/libstratosphere/include/stratosphere/fs/impl/fs_common_mount_name.hpp

@@ -19,10 +19,17 @@ namespace ams::fs::impl {
 
     /* Delimiting of mount names. */
     constexpr inline const char ReservedMountNamePrefixCharacter                = '@';
-    constexpr inline const char * const MountNameDelimiter                      = ":/";
+
+    #define AMS_FS_IMPL_MOUNT_NAME_DELIMITER     ":/"
+    #define AMS_FS_IMPL_MOUNT_NAME_DELIMITER_LEN 2
+    constexpr inline const char * const MountNameDelimiter = AMS_FS_IMPL_MOUNT_NAME_DELIMITER;
 
     /* Filesystem names. */
-    constexpr inline const char * const HostRootFileSystemMountName             = "@Host";
+    #define AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME     "@Host"
+    #define AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME_LEN 5
+
+    constexpr inline const char * const HostRootFileSystemMountName = AMS_FS_IMPL_HOST_ROOT_FILE_SYSTEM_MOUNT_NAME;
+
     constexpr inline const char * const SdCardFileSystemMountName               = "@Sdcard";
     constexpr inline const char * const GameCardFileSystemMountName             = "@Gc";
 

libraries/libstratosphere/include/stratosphere/fs/impl/fs_priority_utils.hpp

@@ -27,11 +27,13 @@ namespace ams::fs::impl {
         TlsIoPriority_Background = 3,
     };
 
+    #if defined(ATMOSPHERE_OS_HORIZON)
     /* Ensure that TlsIo priority matches libnx priority. */
     static_assert(TlsIoPriority_Normal     == static_cast<TlsIoPriority>(::FsPriority_Normal));
     static_assert(TlsIoPriority_Realtime   == static_cast<TlsIoPriority>(::FsPriority_Realtime));
     static_assert(TlsIoPriority_Low        == static_cast<TlsIoPriority>(::FsPriority_Low));
     static_assert(TlsIoPriority_Background == static_cast<TlsIoPriority>(::FsPriority_Background));
+    #endif
 
     constexpr inline Result ConvertFsPriorityToTlsIoPriority(u8 *out, PriorityRaw priority) {
         AMS_ASSERT(out != nullptr);