meso: skeleton libmesosphere in prep for kernelldr dev

libraries/Makefile

@@ -1,4 +1,4 @@
-ATMOSPHERE_LIBRARIES := libstratosphere
+ATMOSPHERE_LIBRARIES := libmesosphere libstratosphere
 
 TOPTARGETS := all clean
 

libraries/config/common.mk

@@ -63,12 +63,12 @@ export SOURCES      ?=	$(shell find source -type d \
                           -not \( -path source/arch -prune \)  \
                           -not \( -path source/board -prune \) \)
 
-ifneq ($(strip $(wildcard source/$(ATMOSPHERE_ARCH_DIR)./.*)),)
+ifneq ($(strip $(wildcard source/$(ATMOSPHERE_ARCH_DIR)/.*)),)
 SOURCES += $(shell find source/$(ATMOSPHERE_ARCH_DIR)  -type d)
 endif
-ifneq ($(strip $(wildcard source/$(ATMOSPHERE_BOARD_DIR)./.*)),)
+ifneq ($(strip $(wildcard source/$(ATMOSPHERE_BOARD_DIR)/.*)),)
 SOURCES += $(shell find source/$(ATMOSPHERE_BOARD_DIR) -type d)
 endif
-ifneq ($(strip $(wildcard source/$(ATMOSPHERE_OS_DIR)./.*)),)
+ifneq ($(strip $(wildcard source/$(ATMOSPHERE_OS_DIR)/.*)),)
 SOURCES += $(shell find source/$(ATMOSPHERE_OS_DIR) -type d)
 endif

libraries/libmesosphere/Makefile

@@ -0,0 +1,129 @@
+#---------------------------------------------------------------------------------
+# pull in common atmosphere configuration
+#---------------------------------------------------------------------------------
+include  $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/../config/common.mk
+
+#---------------------------------------------------------------------------------
+# options for code generation
+#---------------------------------------------------------------------------------
+DEFINES     := $(ATMOSPHERE_DEFINES) -DATMOSPHERE_IS_MESOSPHERE
+SETTINGS    := $(ATMOSPHERE_SETTINGS) -O2 -mgeneral-regs-only -Werror
+CFLAGS      := $(ATMOSPHERE_CFLAGS) $(SETTINGS) $(DEFINES) $(INCLUDE)
+CXXFLAGS    := $(CFLAGS) $(ATMOSPHERE_CXXFLAGS) -flto
+ASFLAGS     := $(ATMOSPHERE_ASFLAGS) $(SETTINGS)
+
+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 ($(BUILD),$(notdir $(CURDIR)))
+#---------------------------------------------------------------------------------
+
+export VPATH	:=	$(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
+			$(foreach dir,$(DATA),$(CURDIR)/$(dir))
+
+CFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.c)) $(notdir $(wildcard $(dir)/*.board.*.c)) $(notdir $(wildcard $(dir)/*.os.*.c)), \
+                                                      $(notdir $(wildcard $(dir)/*.c))))
+CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).c)))
+CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).c)))
+CFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).c)))
+
+CPPFILES    :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.cpp)) $(notdir $(wildcard $(dir)/*.board.*.cpp)) $(notdir $(wildcard $(dir)/*.os.*.cpp)), \
+                                                      $(notdir $(wildcard $(dir)/*.cpp))))
+CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).cpp)))
+CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).cpp)))
+CPPFILES    +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).cpp)))
+
+SFILES      :=	$(foreach dir,$(SOURCES),$(filter-out $(notdir $(wildcard $(dir)/*.arch.*.s)) $(notdir $(wildcard $(dir)/*.board.*.s)) $(notdir $(wildcard $(dir)/*.os.*.s)), \
+                                                      $(notdir $(wildcard $(dir)/*.s))))
+SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.arch.$(ATMOSPHERE_ARCH_NAME).s)))
+SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.board.$(ATMOSPHERE_BOARD_NAME).s)))
+SFILES      +=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.os.$(ATMOSPHERE_OS_NAME).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 OFILES 	:=	$(OFILES_BIN) $(OFILES_SRC)
+export HFILES	:=	$(addsuffix .h,$(subst .,_,$(BINFILES)))
+
+export INCLUDE	:=	$(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
+			$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
+			-I.
+
+.PHONY: clean all
+
+#---------------------------------------------------------------------------------
+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
+
+#---------------------------------------------------------------------------------
+else
+
+DEPENDS	:=	$(OFILES:.o=.d)
+
+#---------------------------------------------------------------------------------
+# main targets
+#---------------------------------------------------------------------------------
+$(OUTPUT)	:	$(OFILES)
+
+$(OFILES_SRC)	: $(HFILES)
+
+#---------------------------------------------------------------------------------
+%_bin.h %.bin.o	:	%.bin
+#---------------------------------------------------------------------------------
+	@echo $(notdir $<)
+	@$(bin2o)
+
+
+-include $(DEPENDS)
+
+#---------------------------------------------------------------------------------------
+endif
+#---------------------------------------------------------------------------------------
+

libraries/libmesosphere/README.md

@@ -0,0 +1,28 @@
+![License](https://img.shields.io/badge/License-GPLv2-blue.svg)
+
+libmesosphere is a work-in-progress C++ library implementing functionality for the Horizon Kernel.
+
+Licensing
+=====
+
+This software is licensed under the terms of the GPLv2, with exemptions for specific projects noted below.
+
+You can find a copy of the license in the [LICENSE file](LICENSE).
+
+Exemptions:
+* The [yuzu emulator project](https://github.com/yuzu-emu/yuzu) is exempt from GPLv2 licensing and may (at its option) instead license any source code authored for the libmesosphere project as GPLv2 or later.
+
+Credits
+=====
+
+libmesosphere is currently being developed and maintained by __SciresM__.<br>
+
+In addition to those credited in [Atmosphère's credits](https://github.com/Atmosphere-NX/Atmosphere/blob/master/README.md#Credits), we would like to thank for contributing to libmesosphere in some significant way:
+
+* @[devkitPro](https://github.com/devkitPro)
+* @[yellows8](https://github.com/yellows8)
+* @[qlutoo](https://github.com/plutooo)
+* @[hedgeberg](https://github.com/hedgeberg)
+* @[Nintendo](https://github.com/Nintendo)
+* @[NVidia](https://github.com/NVidia)
+* @[Kaphotics](https://github.com/kwsch)

libraries/libmesosphere/include/mesosphere.hpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2019 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
+
+/* All kernel code should have access to libvapours. */
+#include <vapours.hpp>
+
+/* First, pull in core macros (panic, etc). */
+#include "mesosphere/kern_panic.hpp"
+
+/* Primitive types. */
+#include "mesosphere/kern_k_typed_address.hpp"
+
+/* Core functionality. */
+#include "mesosphere/kern_select_k_system_control.hpp"

libraries/libmesosphere/include/mesosphere/board/nintendo/switch/kern_k_system_control.hpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2018-2019 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 <vapours.hpp>
+
+namespace ams::kern {
+
+    class KSystemControl {
+        public:
+
+            /* Panic. */
+            static NORETURN void StopSystem();
+    };
+
+}

libraries/libmesosphere/include/mesosphere/kern_k_typed_address.hpp

@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2018-2019 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 <vapours.hpp>
+
+namespace ams::kern {
+
+#ifndef MESOSPHERE_DISABLE_TYPED_ADDRESSES
+
+    template<bool Virtual, typename T>
+    class KTypedAddress {
+        private:
+            uintptr_t address;
+        public:
+            /* Constructors. */
+            constexpr ALWAYS_INLINE KTypedAddress() : address(0) { /* ... */ }
+            constexpr ALWAYS_INLINE KTypedAddress(uintptr_t a) : address(a) { /* ... */ }
+            template<typename U>
+            constexpr ALWAYS_INLINE explicit KTypedAddress(U *ptr) : address(reinterpret_cast<uintptr_t>(ptr)) { /* ... */ }
+
+            /* Assignment operator. */
+            constexpr ALWAYS_INLINE KTypedAddress operator=(KTypedAddress rhs) {
+                this->address = rhs.address;
+                return *this;
+            }
+
+            /* Arithmetic operators. */
+            template<typename I>
+            constexpr ALWAYS_INLINE KTypedAddress operator+(I rhs) const {
+                static_assert(std::is_integral<I>::value);
+                return this->address + rhs;
+            }
+
+            template<typename I>
+            constexpr ALWAYS_INLINE KTypedAddress operator-(I rhs) const {
+                static_assert(std::is_integral<I>::value);
+                return this->address - rhs;
+            }
+
+            template<typename I>
+            constexpr ALWAYS_INLINE KTypedAddress operator+=(I rhs) {
+                static_assert(std::is_integral<I>::value);
+                this->address += rhs;
+                return *this;
+            }
+
+            template<typename I>
+            constexpr ALWAYS_INLINE KTypedAddress operator-=(I rhs) {
+                static_assert(std::is_integral<I>::value);
+                this->address -= rhs;
+                return *this;
+            }
+
+            /* Logical operators. */
+            constexpr ALWAYS_INLINE uintptr_t operator&(uintptr_t mask) const {
+                return this->address & mask;
+            }
+
+            constexpr ALWAYS_INLINE uintptr_t operator|(uintptr_t mask) const {
+                return this->address | mask;
+            }
+
+            constexpr ALWAYS_INLINE uintptr_t operator<<(int shift) const {
+                return this->address << shift;
+            }
+
+            constexpr ALWAYS_INLINE uintptr_t operator>>(int shift) const {
+                return this->address >> shift;
+            }
+
+            /* Comparison operators. */
+            constexpr ALWAYS_INLINE bool operator==(KTypedAddress rhs) const {
+                return this->address == rhs.address;
+            }
+
+            constexpr ALWAYS_INLINE bool operator!=(KTypedAddress rhs) const {
+                return this->address != rhs.address;
+            }
+
+            constexpr ALWAYS_INLINE bool operator<(KTypedAddress rhs) const {
+                return this->address < rhs.address;
+            }
+
+            constexpr ALWAYS_INLINE bool operator<=(KTypedAddress rhs) const {
+                return this->address <= rhs.address;
+            }
+
+            constexpr ALWAYS_INLINE bool operator>(KTypedAddress rhs) const {
+                return this->address > rhs.address;
+            }
+
+            constexpr ALWAYS_INLINE bool operator>=(KTypedAddress rhs) const {
+                return this->address >= rhs.address;
+            }
+
+            /* For convenience, also define comparison operators versus uintptr_t. */
+            constexpr ALWAYS_INLINE bool operator==(uintptr_t rhs) const {
+                return this->address == rhs;
+            }
+
+            constexpr ALWAYS_INLINE bool operator!=(uintptr_t rhs) const {
+                return this->address != rhs;
+            }
+
+            /* TODO: <, <=, >, >= against uintptr_t? would need to be declared outside of class. Maybe worth it. */
+
+            /* Allow getting the address explicitly, for use in accessors. */
+            constexpr ALWAYS_INLINE uintptr_t GetValue() const {
+                return this->address;
+            }
+
+    };
+
+    struct KPhysicalAddressTag{};
+    struct KVirtualAddressTag{};
+    struct KProcessAddressTag{};
+
+    using KPhysicalAddress = KTypedAddress<false, KPhysicalAddressTag>;
+    using KVirtualAddress  = KTypedAddress<true,  KVirtualAddressTag>;
+    using KProcessAddress  = KTypedAddress<true,  KProcessAddressTag>;
+
+    /* Define accessors. */
+    template<bool Virtual, typename T>
+    constexpr ALWAYS_INLINE uintptr_t GetInteger(KTypedAddress<Virtual, T> address) {
+        return address.GetValue();
+    }
+
+    template<typename T, typename U>
+    constexpr ALWAYS_INLINE T *GetPointer(KTypedAddress<true, U> address) {
+        return CONST_FOLD(reinterpret_cast<T *>(address.GetValue()));
+    }
+
+    template<typename T>
+    constexpr ALWAYS_INLINE void *GetVoidPointer(KTypedAddress<true, T> address) {
+        return CONST_FOLD(reinterpret_cast<void *>(address.GetValue()));
+    }
+
+#else
+
+    /* Plausibly, we may not want compiler overhead from using strongly typed addresses. */
+    /* In this case, we should just use uintptr_t. */
+    using KPhysicalAddress = uintptr_t;
+    using KVirtualAddress  = uintptr_t;
+    using KProcessAddress  = uintptr_t;
+
+    /* Define accessors. */
+    constexpr ALWAYS_INLINE uintptr_t GetInteger(uintptr_t address) {
+        return address;
+    }
+
+    template<typename T>
+    constexpr ALWAYS_INLINE T *GetPointer(uintptr_t address) {
+        return CONST_FOLD(reinterpret_cast<T *>(address));
+    }
+
+    template<typename T>
+    constexpr ALWAYS_INLINE void *GetVoidPointer(uintptr_t address) {
+        return CONST_FOLD(reinterpret_cast<void *>(address));
+    }
+
+#endif
+
+    template<typename T>
+    constexpr inline T Null = [] {
+        if constexpr (std::is_same<T, uintptr_t>::value) {
+            return 0;
+        } else {
+            static_assert(std::is_same<T, KPhysicalAddress>::value ||
+                          std::is_same<T, KVirtualAddress>::value  ||
+                          std::is_same<T, KProcessAddress>::value);
+            return T(0);
+        }
+    }();
+
+    /* Basic type validations. */
+    static_assert(sizeof(KPhysicalAddress) == sizeof(uintptr_t));
+    static_assert(sizeof(KVirtualAddress)  == sizeof(uintptr_t));
+    static_assert(sizeof(KProcessAddress)  == sizeof(uintptr_t));
+
+    static_assert(std::is_trivially_destructible<KPhysicalAddress>::value);
+    static_assert(std::is_trivially_destructible<KVirtualAddress>::value);
+    static_assert(std::is_trivially_destructible<KProcessAddress>::value);
+
+    static_assert(Null<uintptr_t>        == 0);
+    static_assert(Null<KPhysicalAddress> == Null<uintptr_t>);
+    static_assert(Null<KVirtualAddress>  == Null<uintptr_t>);
+    static_assert(Null<KProcessAddress>  == Null<uintptr_t>);
+
+    /* Arithmetic validations. */
+    static_assert(KPhysicalAddress(10) + 5 == KPhysicalAddress(15));
+    static_assert(KPhysicalAddress(10) - 5 == KPhysicalAddress(5));
+    static_assert([]{ KPhysicalAddress v(10); v += 5; return v; }() == KPhysicalAddress(15));
+    static_assert([]{ KPhysicalAddress v(10); v -= 5; return v; }() == KPhysicalAddress(5));
+
+    /* Logical validations. */
+    static_assert((KPhysicalAddress(0b11111111) >> 1)         == 0b01111111);
+    static_assert((KPhysicalAddress(0b10101010) >> 1)         == 0b01010101);
+    static_assert((KPhysicalAddress(0b11111111) << 1)        == 0b111111110);
+    static_assert((KPhysicalAddress(0b01010101) << 1)         == 0b10101010);
+    static_assert((KPhysicalAddress(0b11111111) & 0b01010101) == 0b01010101);
+    static_assert((KPhysicalAddress(0b11111111) & 0b10101010) == 0b10101010);
+    static_assert((KPhysicalAddress(0b01010101) & 0b10101010) == 0b00000000);
+    static_assert((KPhysicalAddress(0b00000000) | 0b01010101) == 0b01010101);
+    static_assert((KPhysicalAddress(0b11111111) | 0b01010101) == 0b11111111);
+    static_assert((KPhysicalAddress(0b10101010) | 0b01010101) == 0b11111111);
+
+    /* Comparisons. */
+    static_assert(KPhysicalAddress(0) == KPhysicalAddress(0));
+    static_assert(KPhysicalAddress(0) != KPhysicalAddress(1));
+    static_assert(KPhysicalAddress(0) <  KPhysicalAddress(1));
+    static_assert(KPhysicalAddress(0) <= KPhysicalAddress(1));
+    static_assert(KPhysicalAddress(1) >  KPhysicalAddress(0));
+    static_assert(KPhysicalAddress(1) >= KPhysicalAddress(0));
+
+    static_assert(!(KPhysicalAddress(0) == KPhysicalAddress(1)));
+    static_assert(!(KPhysicalAddress(0) != KPhysicalAddress(0)));
+    static_assert(!(KPhysicalAddress(1) <  KPhysicalAddress(0)));
+    static_assert(!(KPhysicalAddress(1) <= KPhysicalAddress(0)));
+    static_assert(!(KPhysicalAddress(0) >  KPhysicalAddress(1)));
+    static_assert(!(KPhysicalAddress(0) >= KPhysicalAddress(1)));
+
+    /* Accessors. */
+    static_assert(15 == GetInteger(KPhysicalAddress(15)));
+    static_assert(0  == GetInteger(Null<KPhysicalAddress>));
+    /* TODO: reinterpret_cast<> not valid in a constant expression, can't test get pointers. */
+
+}

libraries/libmesosphere/include/mesosphere/kern_panic.hpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2018-2019 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 <vapours.hpp>
+
+namespace ams::kern {
+
+    NORETURN void Panic(const char *file, int line, const char *format, ...);
+    NORETURN void Panic();
+
+}
+
+#ifdef MESOSPHERE_ENABLE_DEBUG_PRINT
+#define MESOSPHERE_PANIC(...) ams::kern::Panic(__FILE__, __LINE__, __VA_ARGS__)
+#else
+#define MESOSPHERE_PANIC(...) ams::kern::Panic()
+#endif
+
+#ifdef MESOSPHERE_ENABLE_ASSERTIONS
+#define MESOSPHERE_ASSERT_IMPL(expr, ...)  \
+    ({                                     \
+        if (AMS_UNLIKELY(!expr)) {         \
+            MESOSPHERE_PANIC(__VA_ARGS__); \
+        }                                  \
+    })
+#else
+#define MESOSPHERE_ASSERT_IMPL(expr, ...) do { } while (0)
+#endif
+
+#define MESOSPHERE_ASSERT(expr)   MESOSPHERE_ASSERT_IMPL(expr, "Assertion failed: %s", #expr)
+#define MESOSPHERE_R_ASSERT(expr) MESOSPHERE_ASSERT_IMPL(R_SUCCEEDED(expr), "Result assertion failed: %s", #expr)
+
+#define MESOSPHERE_ABORT() MESOSPHERE_PANIC("Abort()");
+
+#define MESOSPHERE_ABORT_UNLESS(expr)               \
+    ({                                              \
+        if (AMS_UNLIKELY(!expr)) {                  \
+            MESOSPHERE_PANIC("Abort(): %s", #expr); \
+        }                                           \
+    })

libraries/libmesosphere/include/mesosphere/kern_select_k_system_control.hpp

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2018-2019 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
+
+#ifdef ATMOSPHERE_BOARD_NINTENDO_SWITCH
+    #include "board/nintendo/switch/kern_k_system_control.hpp"
+#else
+    #error "Unknown board for KSystemControl"
+#endif

libraries/libmesosphere/source/board/nintendo/switch/kern_k_system_control.cpp

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2018-2019 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/>.
+ */
+#include <mesosphere.hpp>
+#include "kern_secure_monitor.hpp"
+
+namespace ams::kern {
+
+    void KSystemControl::StopSystem() {
+        /* TODO: smc::Panic(0xF00); */
+        while (true) { /* ... */ }
+    }
+
+}

libraries/libmesosphere/source/board/nintendo/switch/kern_secure_monitor.hpp

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2018-2019 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 <mesosphere.hpp>
+
+namespace ams::kern::smc {
+
+    /* TODO: Secure Monitor API. */
+
+}

libraries/libmesosphere/source/kern_panic.cpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2018-2019 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/>.
+ */
+#include <mesosphere.hpp>
+
+namespace ams::result::impl {
+
+    NORETURN void OnResultAssertion(Result result) {
+        MESOSPHERE_PANIC("OnResultAssertion(2%03d-%04d)", result.GetModule(), result.GetDescription());
+    }
+
+}
+
+namespace ams::kern {
+
+    namespace {
+
+        NORETURN void StopSystem() {
+            KSystemControl::StopSystem();
+        }
+
+    }
+
+    NORETURN WEAK_SYMBOL void Panic(const char *file, int line, const char *format, ...) {
+        /* TODO: Implement printing, log this information. */
+        StopSystem();
+    }
+
+    NORETURN WEAK_SYMBOL void Panic() {
+        StopSystem();
+    }
+
+}

libraries/libstratosphere/source/ams/ams_environment.cpp

@@ -36,7 +36,7 @@ namespace ams {
 
     extern ncm::ProgramId CurrentProgramId;
 
-    void WEAK ExceptionHandler(FatalErrorContext *ctx) {
+    void WEAK_SYMBOL ExceptionHandler(FatalErrorContext *ctx) {
         R_ASSERT(amsBpcInitialize());
         R_ASSERT(amsBpcRebootToFatalError(ctx));
         while (1) { /* ... */ }

libraries/libstratosphere/source/pm/pm_boot_mode_api.cpp

@@ -19,13 +19,13 @@ namespace ams::pm::bm {
 
     /* Boot Mode API. */
     /* Both functions should be weakly linked, so that they can be overridden by ams::boot2 as needed. */
-    BootMode WEAK GetBootMode() {
+    BootMode WEAK_SYMBOL GetBootMode() {
         PmBootMode boot_mode = PmBootMode_Normal;
         R_ASSERT(pmbmGetBootMode(&boot_mode));
         return static_cast<BootMode>(boot_mode);
     }
 
-    void WEAK SetMaintenanceBoot() {
+    void WEAK_SYMBOL SetMaintenanceBoot() {
         R_ASSERT(pmbmSetMaintenanceBoot());
     }
 

libraries/libstratosphere/source/pm/pm_info_api.cpp

@@ -49,7 +49,7 @@ namespace ams::pm::info {
         return pminfoAtmosphereGetProcessInfo(reinterpret_cast<NcmProgramLocation *>(out_loc), reinterpret_cast<CfgOverrideStatus *>(out_status), static_cast<u64>(process_id));
     }
 
-    Result WEAK HasLaunchedProgram(bool *out, ncm::ProgramId program_id) {
+    Result WEAK_SYMBOL HasLaunchedProgram(bool *out, ncm::ProgramId program_id) {
         std::scoped_lock lk(g_info_lock);
 
         if (g_cached_launched_programs.find(static_cast<u64>(program_id)) != g_cached_launched_programs.end()) {

libraries/libstratosphere/source/pm/pm_shell_api.cpp

@@ -18,7 +18,7 @@
 namespace ams::pm::shell {
 
     /* Shell API. */
-    Result WEAK LaunchProgram(os::ProcessId *out_process_id, const ncm::ProgramLocation &loc, u32 launch_flags) {
+    Result WEAK_SYMBOL LaunchProgram(os::ProcessId *out_process_id, const ncm::ProgramLocation &loc, u32 launch_flags) {
         static_assert(sizeof(ncm::ProgramLocation) == sizeof(NcmProgramLocation));
         static_assert(alignof(ncm::ProgramLocation) == alignof(NcmProgramLocation));
         return pmshellLaunchProgram(launch_flags, reinterpret_cast<const NcmProgramLocation *>(&loc), reinterpret_cast<u64 *>(out_process_id));

libraries/libstratosphere/source/result/result_on_assertion.cpp

@@ -23,7 +23,7 @@ namespace ams::result {
 
 namespace ams::result::impl {
 
-    NORETURN WEAK void OnResultAssertion(Result result) {
+    NORETURN WEAK_SYMBOL void OnResultAssertion(Result result) {
         /* Assert that we should call fatal on result assertion. */
         /* If we shouldn't fatal, this will std::abort(); */
         /* If we should, we'll continue onwards. */

libraries/libstratosphere/source/settings/settings_fwdbg_api.cpp

@@ -20,13 +20,13 @@ namespace ams::settings::fwdbg {
     /* TODO: Implement when libnx wrapper is added. */
     bool IsDebugModeEnabled();
 
-    size_t WEAK GetSettingsItemValueSize(const char *name, const char *key) {
+    size_t WEAK_SYMBOL GetSettingsItemValueSize(const char *name, const char *key) {
         u64 size = 0;
         R_ASSERT(setsysGetSettingsItemValueSize(name, key, &size));
         return size;
     }
 
-    size_t WEAK GetSettingsItemValue(void *dst, size_t dst_size, const char *name, const char *key) {
+    size_t WEAK_SYMBOL GetSettingsItemValue(void *dst, size_t dst_size, const char *name, const char *key) {
         u64 size = 0;
         R_ASSERT(setsysGetSettingsItemValue(name, key, dst, dst_size, &size));
         return size;

libraries/libvapours/include/vapours/defines.hpp

@@ -33,8 +33,10 @@
 
 #define ALIGNED(algn) __attribute__((aligned(algn)))
 #define NORETURN      __attribute__((noreturn))
-#define WEAK          __attribute__((weak))
+#define WEAK_SYMBOL   __attribute__((weak))
+#define ALWAYS_INLINE inline __attribute__((always_inline))
 
+#define CONST_FOLD(x) (__builtin_constant_p(x) ? (x) : (x))
 
 #define CONCATENATE_IMPL(S1, s2) s1##s2
 #define CONCATENATE(s1, s2) CONCATENATE_IMPL(s1, s2)
@@ -44,3 +46,16 @@
 #else
 #define ANONYMOUS_VARIABLE(pref) CONCATENATE(pref, __LINE__)
 #endif
+
+#define AMS_PREDICT(expr, value, _probability) __builtin_expect_with_probability(expr, value, ({ \
+                                                    constexpr double probability = _probability; \
+                                                    static_assert(0.0 <= probability);           \
+                                                    static_assert(probability <= 1.0);           \
+                                                    probability;                                 \
+                                               }))
+
+#define AMS_PREDICT_TRUE(expr, probability)  AMS_PREDICT(!!expr, 1, probability)
+#define AMS_PREDICT_FALSE(expr, probability) AMS_PREDICT(!!expr, 0, probability)
+
+#define AMS_LIKELY(expr)   AMS_PREDICT_TRUE(expr, 1.0)
+#define AMS_UNLIKELY(expr) AMS_PREDICT_FALSE(expr, 1.0)

libraries/libvapours/include/vapours/includes.hpp

@@ -54,11 +54,20 @@
 
 #ifdef ATMOSPHERE_BOARD_NINTENDO_SWITCH
 
+#ifdef ATMOSPHERE_IS_STRATOSPHERE
+
 /* Libnx. */
 #include <switch.h>
 
 #else
 
+/* Non-EL0 code can't include libnx. */
+#include "types.hpp"
+
+#endif
+
+#else
+
 #error "Unsupported board"
 
 #endif /* ATMOSPHERE_BOARD_NINTENDO_SWITCH */

libraries/libvapours/include/vapours/types.hpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2018-2019 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 <cstdint>
+#include <cstddef>
+#include <cstdbool>
+#include <cstdalign>
+
+/* NOTE: This file serves as a substitute for libnx <switch/types.h>. */
+
+typedef uint8_t u8;       ///<   8-bit unsigned integer.
+typedef uint16_t u16;     ///<  16-bit unsigned integer.
+typedef uint32_t u32;     ///<  32-bit unsigned integer.
+typedef uint64_t u64;     ///<  64-bit unsigned integer.
+typedef __uint128_t u128; ///< 128-bit unsigned integer.
+
+typedef int8_t s8;       ///<   8-bit signed integer.
+typedef int16_t s16;     ///<  16-bit signed integer.
+typedef int32_t s32;     ///<  32-bit signed integer.
+typedef int64_t s64;     ///<  64-bit signed integer.
+typedef __int128_t s128; ///< 128-bit unsigned integer.
+
+typedef volatile u8 vu8;     ///<   8-bit volatile unsigned integer.
+typedef volatile u16 vu16;   ///<  16-bit volatile unsigned integer.
+typedef volatile u32 vu32;   ///<  32-bit volatile unsigned integer.
+typedef volatile u64 vu64;   ///<  64-bit volatile unsigned integer.
+typedef volatile u128 vu128; ///< 128-bit volatile unsigned integer.
+
+typedef volatile s8 vs8;     ///<   8-bit volatile signed integer.
+typedef volatile s16 vs16;   ///<  16-bit volatile signed integer.
+typedef volatile s32 vs32;   ///<  32-bit volatile signed integer.
+typedef volatile s64 vs64;   ///<  64-bit volatile signed integer.
+typedef volatile s128 vs128; ///< 128-bit volatile signed integer.
+
+typedef u32 Result;                 ///< Function error code result type.
+
+/// Creates a bitmask from a bit number.
+#ifndef BIT
+#define BIT(n) (1U<<(n))
+#endif
+
+/// Marks a function as not returning, for the purposes of compiler optimization.
+#ifndef NORETURN
+#define NORETURN   __attribute__((noreturn))
+#endif
+
+/// This will get un-defined by <vapours/results/results_common.hpp>
+#define R_SUCCEEDED(res) (res == 0)
+#define R_FAILED(res)    (res != 0)
+
+
+/// Flags a function as (always) inline.
+#define NX_INLINE __attribute__((always_inline)) static inline
+
+/// Flags a function as constexpr in C++14 and above; or as (always) inline otherwise.
+#if __cplusplus >= 201402L
+#define NX_CONSTEXPR NX_INLINE constexpr
+#else
+#define NX_CONSTEXPR NX_INLINE
+#endif