Address CR Comments + Fix Clock Rescaling

app/src/main/cpp/skyline/audio/adpcm_decoder.h

@@ -31,6 +31,6 @@ namespace skyline::audio {
         /**
          * @brief Decodes a buffer of ADPCM data into I16 PCM
          */
-        std::vector<i16> Decode(span<u8> adpcmData);
+        std::vector<i16> Decode(span <u8> adpcmData);
     };
 }

app/src/main/cpp/skyline/audio/resampler.h

@@ -20,6 +20,6 @@ namespace skyline::audio {
          * @param ratio The conversion ratio needed
          * @param channelCount The amount of channels the buffer contains
          */
-        std::vector<i16> ResampleBuffer(span<i16> inputBuffer, double ratio, u8 channelCount);
+        std::vector<i16> ResampleBuffer(span <i16> inputBuffer, double ratio, u8 channelCount);
     };
 }

app/src/main/cpp/skyline/common.h

@@ -30,9 +30,9 @@ namespace fmt {
     /**
      * @brief A std::bitset formatter for {fmt}
      */
-    template <size_t N>
+    template<size_t N>
-    struct formatter<std::bitset<N>>: formatter<std::string> {
+    struct formatter<std::bitset<N>> : formatter<std::string> {
-        template <typename FormatContext>
+        template<typename FormatContext>
         constexpr auto format(const std::bitset<N> &s, FormatContext &ctx) {
             return formatter<std::string>::format(s.to_string(), ctx);
         }
@@ -92,9 +92,9 @@ namespace skyline {
 
     namespace util {
         /**
-         * @brief A way to implicitly cast all pointers to u64s, this is used for {fmt} as we use 0x{:X} to print pointers
+         * @brief A way to implicitly cast all pointers to uintptr_t, this is used for {fmt} as we use 0x{:X} to print pointers
          * @note There's the exception of signed char pointers as they represent C Strings
-         * @note This does not cover std::shared_ptr or std::unique_ptr and those will have to be explicitly casted to u64 or passed through fmt::ptr
+         * @note This does not cover std::shared_ptr or std::unique_ptr and those will have to be explicitly casted to uintptr_t or passed through fmt::ptr
          */
         template<class T>
         constexpr auto FmtCast(T object) {
@@ -102,7 +102,7 @@ namespace skyline {
                 if constexpr (std::is_same<char, typename std::remove_cv<typename std::remove_pointer<T>::type>::type>::value)
                     return reinterpret_cast<typename std::common_type<char *, T>::type>(object);
                 else
-                    return reinterpret_cast<const u64>(object);
+                    return reinterpret_cast<const uintptr_t>(object);
             else
                 return object;
         }
@@ -153,7 +153,7 @@ namespace skyline {
         }
 
         template<class T>
-        size_t PointerValue(T *item) {
+        uintptr_t PointerValue(T *item) {
             return reinterpret_cast<uintptr_t>(item);
         }
 
@@ -244,7 +244,7 @@ namespace skyline {
         template<size_t Size>
         constexpr std::array<u8, Size> HexStringToArray(std::string_view string) {
             if (string.size() != Size * 2)
-                throw exception("Invalid size");
+                throw exception("String size: {} (Expected {})", string.size(), Size);
             std::array<u8, Size> result;
             for (size_t i{}; i < Size; i++) {
                 size_t index{i * 2};
@@ -255,9 +255,11 @@ namespace skyline {
 
         template<class Type>
         constexpr Type HexStringToInt(std::string_view string) {
+            if (string.size() > sizeof(Type) * 2)
+                throw exception("String size larger than type: {} (sizeof(Type): {})", string.size(), sizeof(Type));
             Type result{};
             size_t offset{(sizeof(Type) * 8) - 4};
-            for (size_t index{}; index < std::min(sizeof(Type) * 2, string.size()); index++, offset -= 4) {
+            for (size_t index{}; index < string.size(); index++, offset -= 4) {
                 char digit{string[index]};
                 if (digit >= '0' && digit <= '9')
                     result |= static_cast<Type>(digit - '0') << offset;

app/src/main/cpp/skyline/common/circular_buffer.h

@@ -28,7 +28,7 @@ namespace skyline {
          * @param copyOffset The offset into the buffer after which to use memcpy rather than copyFunction, -1 will use it for the entire buffer
          * @return The amount of data written into the input buffer in units of Type
          */
-        inline size_t Read(span<Type> buffer, void copyFunction(Type *, Type *) = {}, ssize_t copyOffset = -1) {
+        inline size_t Read(span <Type> buffer, void copyFunction(Type *, Type *) = {}, ssize_t copyOffset = -1) {
             std::lock_guard guard(mtx);
 
             if (empty)
@@ -91,7 +91,7 @@ namespace skyline {
         /**
          * @brief Appends data from the specified buffer into this buffer
          */
-        inline void Append(span<Type> buffer) {
+        inline void Append(span <Type> buffer) {
             std::lock_guard guard(mtx);
 
             Type *pointer{buffer.data()};

app/src/main/cpp/skyline/common/circular_queue.h

@@ -23,6 +23,16 @@ namespace skyline {
       public:
         inline CircularQueue(size_t size) : vector((size + 1) * sizeof(Type)) {}
 
+        inline CircularQueue(const CircularQueue &) = delete;
+
+        inline CircularQueue &operator=(const CircularQueue &) = delete;
+
+        inline CircularQueue(CircularQueue &&other) : vector(std::move(other.vector)), consumptionMutex(std::move(other.consumptionMutex)), consumeCondition(std::move(other.consumeCondition)), productionMutex(std::move(other.productionMutex)), produceCondition(std::move(other.produceCondition)) {
+            this->start = other.start;
+            this->end = other.end;
+            other.start = other.end = nullptr;
+        }
+
         inline ~CircularQueue() {
             while (start != end) {
                 auto next{start + 1};
@@ -66,9 +76,9 @@ namespace skyline {
             produceCondition.notify_one();
         }
 
-        inline void Append(span<Type> buffer) {
+        inline void Append(span <Type> buffer) {
             std::unique_lock lock(productionMutex);
-            for (auto &item : buffer) {
+            for (const auto &item : buffer) {
                 auto next{end + 1};
                 next = (next == reinterpret_cast<Type *>(vector.end().base())) ? reinterpret_cast<Type *>(vector.begin().base()) : next;
                 if (next == start) {
@@ -86,9 +96,9 @@ namespace skyline {
          * @param tranformation A function that takes in an item of TransformedType as input and returns an item of Type
          */
         template<typename TransformedType, typename Transformation>
-        inline void AppendTranform(span<TransformedType> buffer, Transformation transformation) {
+        inline void AppendTranform(span <TransformedType> buffer, Transformation transformation) {
             std::unique_lock lock(productionMutex);
-            for (auto &item : buffer) {
+            for (const auto &item : buffer) {
                 auto next{end + 1};
                 next = (next == reinterpret_cast<Type *>(vector.end().base())) ? reinterpret_cast<Type *>(vector.begin().base()) : next;
                 if (next == start) {

app/src/main/cpp/skyline/common/signal.cpp

@@ -48,7 +48,7 @@ namespace skyline::signal {
         signalException.signal = signal;
         signalException.pc = context->uc_mcontext.pc;
         if (signal == SIGSEGV)
-            signalException.faultAddress = info->si_addr;
+            signalException.fault = info->si_addr;
         SignalExceptionPtr = std::make_exception_ptr(signalException);
         context->uc_mcontext.pc = reinterpret_cast<u64>(&ExceptionThrow);
 

app/src/main/cpp/skyline/common/signal.h

@@ -15,13 +15,13 @@ namespace skyline::signal {
       public:
         int signal{};
         u64 pc{};
-        void *faultAddress{};
+        void *fault{};
 
         inline std::string what() const {
-            if (!faultAddress)
+            if (!fault)
                 return fmt::format("Signal: {} (PC: 0x{:X})", strsignal(signal), pc);
             else
-                return fmt::format("Signal: {} @ 0x{:X} (PC: 0x{:X})", strsignal(signal), reinterpret_cast<u64>(faultAddress), pc);
+                return fmt::format("Signal: {} @ 0x{:X} (PC: 0x{:X})", strsignal(signal), reinterpret_cast<uintptr_t>(fault), pc);
         }
     };
 

app/src/main/cpp/skyline/gpu/memory_manager.h

@@ -99,14 +99,13 @@ namespace skyline {
              */
             bool Unmap(u64 virtAddr, u64 size);
 
-
             void Read(u8 *destination, u64 virtAddr, u64 size) const;
 
             /**
              * @brief Reads in a span from a region of the virtual address space
              */
             template<typename T>
-            void Read(span<T> destination, u64 virtAddr) const {
+            void Read(span <T> destination, u64 virtAddr) const {
                 Read(reinterpret_cast<u8 *>(destination.data()), virtAddr, destination.size_bytes());
             }
 
@@ -127,7 +126,7 @@ namespace skyline {
              * @brief Writes out a span to a region of the virtual address space
              */
             template<typename T>
-            void Write(span<T> source, u64 virtAddr) const {
+            void Write(span <T> source, u64 virtAddr) const {
                 Write(reinterpret_cast<u8 *>(source.data()), virtAddr, source.size_bytes());
             }
 

app/src/main/cpp/skyline/kernel/memory.cpp

@@ -41,7 +41,7 @@ namespace skyline::kernel {
         // Search for a suitable carveout in host AS to fit the guest AS inside of
         std::ifstream mapsFile("/proc/self/maps");
         std::string maps((std::istreambuf_iterator<char>(mapsFile)), std::istreambuf_iterator<char>());
-        size_t line{}, start{1ULL << 35}, alignedStart{1ULL << 35}; // 1 << 35 is where QC KGSL (Kernel Graphic Support Layer) maps down from, we skip over this or KGSL goes OOM
+        size_t line{}, start{1ULL << 35}, alignedStart{1ULL << 35}; // Qualcomm KGSL (Kernel Graphic Support Layer/Kernel GPU driver) maps below 35-bits, reserving it causes KGSL to go OOM
         do {
             auto end{util::HexStringToInt<u64>(std::string_view(maps.data() + line, sizeof(u64) * 2))};
             if (end < start)

app/src/main/cpp/skyline/kernel/memory.h

@@ -186,12 +186,6 @@ namespace skyline {
         };
     }
 
-    namespace loader {
-        class NroLoader;
-        class NsoLoader;
-        class NcaLoader;
-    }
-
     namespace kernel {
         struct ChunkDescriptor {
             u8 *ptr;

app/src/main/cpp/skyline/kernel/svc.cpp

@@ -113,7 +113,7 @@ namespace skyline::kernel::svc {
         }
 
         state.process->NewHandle<type::KPrivateMemory>(destination, size, chunk->permission, memory::states::Stack);
-        memcpy(destination, source, size);
+        std::memcpy(destination, source, size);
 
         auto object{state.process->GetMemoryObject(source)};
         if (!object)
@@ -281,12 +281,11 @@ namespace skyline::kernel::svc {
     }
 
     void SleepThread(const DeviceState &state) {
-        u64 in{state.ctx->gpr.x0};
+        i64 in{static_cast<i64>(state.ctx->gpr.x0)};
-
         switch (in) {
             case 0:
-            case 1:
+            case -1:
-            case 2:
+            case -2:
                 state.logger->Debug("svcSleepThread: Yielding thread: {}", in);
                 break;
             default:
@@ -553,7 +552,7 @@ namespace skyline::kernel::svc {
                 break;
             }
 
-            uint index{};
+            u32 index{};
             for (const auto &object : objectTable) {
                 if (object->signalled) {
                     state.logger->Debug("svcWaitSynchronization: Signalled handle: 0x{:X}", waitHandles[index]);

app/src/main/cpp/skyline/kernel/types/KProcess.h

@@ -183,7 +183,7 @@ namespace skyline {
                         throw exception("GetHandle was called with a deleted handle: 0x{:X}", handle);
                     else
                         throw exception("Tried to get kernel object (0x{:X}) with different type: {} when object is {}", handle, objectType, item->objectType);
-                } catch (const std::out_of_range&) {
+                } catch (const std::out_of_range &) {
                     throw std::out_of_range(fmt::format("GetHandle was called with an invalid handle: 0x{:X}", handle));
                 }
             }

app/src/main/cpp/skyline/loader/nca.cpp

@@ -2,6 +2,7 @@
 // Copyright © 2020 Skyline Team and Contributors (https://github.com/skyline-emu/)
 
 #include <kernel/types/KProcess.h>
+#include <vfs/npdm.h>
 #include "nso.h"
 #include "nca.h"
 
@@ -19,7 +20,7 @@ namespace skyline::loader {
         if (nsoFile == nullptr)
             throw exception("Cannot load an ExeFS that doesn't contain rtld");
 
-        state.process->memory.InitializeVmm(memory::AddressSpaceType::AddressSpace39Bit);
+        state.process->memory.InitializeVmm(process->npdm.meta.flags.type);
 
         auto loadInfo{NsoLoader::LoadNso(nsoFile, process, state)};
         u64 offset{loadInfo.size};

app/src/main/cpp/skyline/nce.cpp

@@ -270,7 +270,7 @@ namespace skyline::nce {
                             *instruction = instr::B((end - patch) + offset, true).raw;
 
                             /* Rescale host clock */
-                            std::memcpy(patch, reinterpret_cast<void *>(&guest::RescaleClock), guest::RescaleClockSize);
+                            std::memcpy(patch, reinterpret_cast<void *>(&guest::RescaleClock), guest::RescaleClockSize * sizeof(u32));
                             patch += guest::RescaleClockSize;
 
                             /* Load result from stack into destination register */

app/src/main/cpp/skyline/services/account/IAccountServiceForApplication.h

@@ -39,7 +39,7 @@ namespace skyline {
             /**
              * @brief Writes a vector of 128-bit user IDs to an output buffer
              */
-            Result WriteUserList(span<u8> buffer, std::vector<UserId> userIds);
+            Result WriteUserList(span <u8> buffer, std::vector<UserId> userIds);
 
           public:
             IAccountServiceForApplication(const DeviceState &state, ServiceManager &manager);

app/src/main/cpp/skyline/services/nvdrv/devices/nvhost_as_gpu.h

@@ -27,43 +27,43 @@ namespace skyline::service::nvdrv::device {
          * @brief Binds a channel to the address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_BIND_CHANNEL
          */
-        NvStatus BindChannel(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus BindChannel(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Reserves a region in the GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_ALLOC_SPACE
          */
-        NvStatus AllocSpace(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus AllocSpace(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Unmaps a region in the GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_UNMAP_BUFFER
          */
-        NvStatus UnmapBuffer(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus UnmapBuffer(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Maps a region in the GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_MODIFY
          */
-        NvStatus Modify(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus Modify(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Returns the application's GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_GET_VA_REGIONS
          */
-        NvStatus GetVaRegions(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus GetVaRegions(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Initializes the application's GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_ALLOC_AS_EX
          */
-        NvStatus AllocAsEx(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus AllocAsEx(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         /**
          * @brief Remaps a region of the GPU address space
          * @url https://switchbrew.org/wiki/NV_services#NVGPU_AS_IOCTL_REMAP
          */
-        NvStatus Remap(IoctlType type, span<u8> buffer, span<u8> inlineBuffer);
+        NvStatus Remap(IoctlType type, span <u8> buffer, span <u8> inlineBuffer);
 
         NVDEVICE_DECL(
             NVFUNC(0x4101, NvHostAsGpu, BindChannel),

app/src/main/cpp/skyline/vfs/backing.h

@@ -42,13 +42,13 @@ namespace skyline::vfs {
          * @param offset The offset to start reading from
          * @return The amount of bytes read
          */
-        virtual size_t Read(span<u8> output, size_t offset = 0) = 0;
+        virtual size_t Read(span <u8> output, size_t offset = 0) = 0;
 
         /**
          * @brief Implicit casting for reading into spans of different types
          */
         template<class T, typename std::enable_if<!std::is_same_v<T, u8>, bool>::type = true>
-        inline size_t Read(span<T> output, size_t offset = 0) {
+        inline size_t Read(span <T> output, size_t offset = 0) {
             return Read(output.template cast<u8>(), offset);
         }
 
@@ -70,7 +70,7 @@ namespace skyline::vfs {
          * @param offset The offset where the input buffer should be written
          * @return The amount of bytes written
          */
-        virtual size_t Write(span<u8> input, size_t offset = 0) {
+        virtual size_t Write(span <u8> input, size_t offset = 0) {
             throw exception("This backing does not support being written to");
         }
 

app/src/main/cpp/skyline/vfs/os_filesystem.h

@@ -38,4 +38,5 @@ namespace skyline::vfs {
         OsFileSystemDirectory(const std::string &path, ListMode listMode);
 
         std::vector<Entry> Read();
-    };}
+    };
+}

app/src/main/cpp/skyline/vfs/region_backing.h

@@ -22,7 +22,7 @@ namespace skyline::vfs {
          */
         RegionBacking(const std::shared_ptr<vfs::Backing> &backing, size_t offset, size_t size, Mode mode = {true, false, false}) : Backing(mode, size), backing(backing), baseOffset(offset) {};
 
-        size_t Read(span<u8> output, size_t offset = 0) {
+        size_t Read(span <u8> output, size_t offset = 0) {
             if (!mode.read)
                 throw exception("Attempting to read a backing that is not readable");
             if (size - offset < output.size())

app/src/main/res/layout/controller_item.xml

@@ -8,7 +8,8 @@
         android:clickable="true"
         android:focusable="true"
         android:orientation="vertical"
-        android:padding="16dp">
+        android:paddingVertical="8dp"
+        android:paddingHorizontal="16dp">
 
     <TextView
             android:id="@+id/text_title"