Merge branch 'master' into mesosphere-dev

libraries/libvapours/include/vapours/includes.hpp

@@ -26,36 +26,29 @@
 #include <climits>
 #include <cctype>
 
-
+/* C++ headers. */
 #include <type_traits>
 #include <algorithm>
 #include <iterator>
 #include <limits>
-#include <atomic>
 #include <random>
-
-/* Stratosphere wants stdlib headers, others do not.. */
-#ifdef ATMOSPHERE_IS_STRATOSPHERE
-
-/* C++ headers. */
+#include <atomic>
 #include <utility>
 #include <optional>
-#include <memory>
-#include <mutex>
-#include <shared_mutex>
 #include <functional>
 #include <tuple>
 #include <array>
+
+/* Stratosphere wants additional libstdc++ headers, others do not. */
+#ifdef ATMOSPHERE_IS_STRATOSPHERE
+
+#include <memory>
+#include <mutex>
+#include <shared_mutex>
 #include <map>
 #include <unordered_map>
 #include <set>
 
-#endif /* ATMOSPHERE_IS_STRATOSPHERE */
-
-#ifdef ATMOSPHERE_BOARD_NINTENDO_NX
-
-#ifdef ATMOSPHERE_IS_STRATOSPHERE
-
 /* Libnx. */
 #include <switch.h>
 
@@ -64,13 +57,7 @@
 /* Non-EL0 code can't include libnx. */
 #include "types.hpp"
 
-#endif
-
-#else
-
-#error "Unsupported board"
-
-#endif /* ATMOSPHERE_BOARD_NINTENDO_NX */
+#endif /* ATMOSPHERE_IS_STRATOSPHERE */
 
 /* Atmosphere meta. */
 #include "ams_version.h"

libraries/libvapours/include/vapours/types.hpp

@@ -52,6 +52,31 @@ typedef u32 Result;          ///< Function error code result type.
 #define BIT(n) (1U<<(n))
 #endif
 
+/// Creates a bitmask from a bit number (long).
+#ifndef BITL
+#define BITL(n) (1UL<<(n))
+#endif
+
+/// Creates a bitmask representing the n least significant bits.
+#ifndef MASK
+#define MASK(n) (BIT(n) - 1U)
+#endif
+
+/// Creates a bitmask representing the n least significant bits (long).
+#ifndef MASKL
+#define MASKL(n) (BITL(n) - 1UL)
+#endif
+
+/// Creates a bitmask for bit range extraction.
+#ifndef MASK2
+#define MASK2(a,b) (MASK(a) & ~MASK(b))
+#endif
+
+/// Creates a bitmask for bit range extraction (long).
+#ifndef MASK2L
+#define MASK2L(a,b) (MASKL(a) & ~MASKL(b))
+#endif
+
 /// Marks a function as not returning, for the purposes of compiler optimization.
 #ifndef NORETURN
 #define NORETURN   __attribute__((noreturn))

libraries/libvapours/include/vapours/util.hpp

@@ -28,3 +28,4 @@
 #include "util/util_intrusive_list.hpp"
 #include "util/util_intrusive_red_black_tree.hpp"
 #include "util/util_tinymt.hpp"
+#include "util/util_bitutil.hpp"

libraries/libvapours/include/vapours/util/util_bitutil.hpp

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2018-2020 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 "../defines.hpp"
+#include "../types.hpp"
+
+namespace ams::util {
+
+    template <typename T>
+    class BitsOf {
+        private:
+            static_assert(std::is_integral<T>::value);
+
+            static constexpr ALWAYS_INLINE int GetLsbPos(T v) {
+                return __builtin_ctzll(static_cast<u64>(v));
+            }
+
+            T value;
+        public:
+            /* Note: GCC has a bug in constant-folding here. Workaround: wrap entire caller with constexpr. */
+            constexpr ALWAYS_INLINE BitsOf(T value = T(0u)) : value(value) {
+                /* ... */
+            }
+
+            constexpr ALWAYS_INLINE bool operator==(const BitsOf &other) const {
+                return this->value == other.value;
+            }
+
+            constexpr ALWAYS_INLINE bool operator!=(const BitsOf &other) const {
+                return this->value != other.value;
+            }
+
+            constexpr ALWAYS_INLINE int operator*() const {
+                return GetLsbPos(this->value);
+            }
+
+            constexpr ALWAYS_INLINE BitsOf &operator++() {
+                this->value &= ~(T(1u) << GetLsbPos(this->value));
+                return *this;
+            }
+
+            constexpr ALWAYS_INLINE BitsOf &operator++(int) {
+                BitsOf ret(this->value);
+                ++(*this);
+                return ret;
+            }
+
+            constexpr ALWAYS_INLINE BitsOf begin() const {
+                return *this;
+            }
+
+            constexpr ALWAYS_INLINE BitsOf end() const {
+                return BitsOf(T(0u));
+            }
+    };
+
+    template<typename T = u64, typename ...Args>
+    constexpr ALWAYS_INLINE T CombineBits(Args... args) {
+        return (... | (T(1u) << args));
+    }
+
+}