Merge 894d420694 into 3d9126ba87

Pull request #418 - set/Pull request #418 - set/am: Fix code for getting language codes

src/common/file_util.cpp

@@ -809,16 +809,16 @@ IOFile::~IOFile() {
     Close();
 }
 
-IOFile::IOFile(IOFile&& other) noexcept {
+IOFile::IOFile(IOFile&& other) {
     Swap(other);
 }
 
-IOFile& IOFile::operator=(IOFile&& other) noexcept {
+IOFile& IOFile::operator=(IOFile&& other) {
     Swap(other);
     return *this;
 }
 
-void IOFile::Swap(IOFile& other) noexcept {
+void IOFile::Swap(IOFile& other) {
     std::swap(m_file, other.m_file);
     std::swap(m_good, other.m_good);
 }

src/common/file_util.h

@@ -160,10 +160,10 @@ public:
 
     ~IOFile();
 
-    IOFile(IOFile&& other) noexcept;
-    IOFile& operator=(IOFile&& other) noexcept;
+    IOFile(IOFile&& other);
+    IOFile& operator=(IOFile&& other);
 
-    void Swap(IOFile& other) noexcept;
+    void Swap(IOFile& other);
 
     bool Open(const std::string& filename, const char openmode[]);
     bool Close();
@@ -202,15 +202,11 @@ public:
         return items_written;
     }
 
-    template <typename T>
-    size_t ReadBytes(T* data, size_t length) {
-        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
+    size_t ReadBytes(void* data, size_t length) {
         return ReadArray(reinterpret_cast<char*>(data), length);
     }
 
-    template <typename T>
-    size_t WriteBytes(const T* data, size_t length) {
-        static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
+    size_t WriteBytes(const void* data, size_t length) {
         return WriteArray(reinterpret_cast<const char*>(data), length);
     }
 

src/common/memory_util.cpp

@@ -167,7 +167,8 @@ std::string MemUsage() {
         return "MemUsage Error";
 
     if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
-        Ret = fmt::format("{} K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7));
+        Ret = Common::StringFromFormat(
+            "%s K", Common::ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str());
 
     CloseHandle(hProcess);
     return Ret;

src/common/string_util.cpp

@@ -46,6 +46,76 @@ bool AsciiToHex(const char* _szValue, u32& result) {
     return true;
 }
 
+bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args) {
+    int writtenCount;
+
+#ifdef _MSC_VER
+    // You would think *printf are simple, right? Iterate on each character,
+    // if it's a format specifier handle it properly, etc.
+    //
+    // Nooooo. Not according to the C standard.
+    //
+    // According to the C99 standard (7.19.6.1 "The fprintf function")
+    //     The format shall be a multibyte character sequence
+    //
+    // Because some character encodings might have '%' signs in the middle of
+    // a multibyte sequence (SJIS for example only specifies that the first
+    // byte of a 2 byte sequence is "high", the second byte can be anything),
+    // printf functions have to decode the multibyte sequences and try their
+    // best to not screw up.
+    //
+    // Unfortunately, on Windows, the locale for most languages is not UTF-8
+    // as we would need. Notably, for zh_TW, Windows chooses EUC-CN as the
+    // locale, and completely fails when trying to decode UTF-8 as EUC-CN.
+    //
+    // On the other hand, the fix is simple: because we use UTF-8, no such
+    // multibyte handling is required as we can simply assume that no '%' char
+    // will be present in the middle of a multibyte sequence.
+    //
+    // This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
+    static locale_t c_locale = nullptr;
+    if (!c_locale)
+        c_locale = _create_locale(LC_ALL, ".1252");
+    writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
+#else
+    writtenCount = vsnprintf(out, outsize, format, args);
+#endif
+
+    if (writtenCount > 0 && writtenCount < outsize) {
+        out[writtenCount] = '\0';
+        return true;
+    } else {
+        out[outsize - 1] = '\0';
+        return false;
+    }
+}
+
+std::string StringFromFormat(const char* format, ...) {
+    va_list args;
+    char* buf = nullptr;
+#ifdef _WIN32
+    int required = 0;
+
+    va_start(args, format);
+    required = _vscprintf(format, args);
+    buf = new char[required + 1];
+    CharArrayFromFormatV(buf, required + 1, format, args);
+    va_end(args);
+
+    std::string temp = buf;
+    delete[] buf;
+#else
+    va_start(args, format);
+    if (vasprintf(&buf, format, args) < 0)
+        NGLOG_ERROR(Common, "Unable to allocate memory for string");
+    va_end(args);
+
+    std::string temp = buf;
+    free(buf);
+#endif
+    return temp;
+}
+
 // For Debugging. Read out an u8 array.
 std::string ArrayToString(const u8* data, size_t size, int line_len, bool spaces) {
     std::ostringstream oss;

src/common/string_util.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <cstdarg>
 #include <cstddef>
 #include <iomanip>
 #include <sstream>
@@ -19,6 +20,19 @@ std::string ToLower(std::string str);
 /// Make a string uppercase
 std::string ToUpper(std::string str);
 
+std::string StringFromFormat(const char* format, ...);
+// Cheap!
+bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args);
+
+template <size_t Count>
+inline void CharArrayFromFormat(char (&out)[Count], const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    CharArrayFromFormatV(out, Count, format, args);
+    va_end(args);
+}
+
+// Good
 std::string ArrayToString(const u8* data, size_t size, int line_len = 20, bool spaces = true);
 
 std::string StripSpaces(const std::string& s);

src/common/timer.cpp

@@ -2,10 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include <ctime>
-
-#include <fmt/format.h>
-
+#include <time.h>
 #ifdef _WIN32
 #include <windows.h>
 // windows.h needs to be included before other windows headers
@@ -107,8 +104,8 @@ std::string Timer::GetTimeElapsedFormatted() const {
     // Hours
     u32 Hours = Minutes / 60;
 
-    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours, Minutes % 60, Seconds % 60,
-                                     Milliseconds % 1000);
+    std::string TmpStr = StringFromFormat("%02i:%02i:%02i:%03i", Hours, Minutes % 60, Seconds % 60,
+                                          Milliseconds % 1000);
     return TmpStr;
 }
 
@@ -168,11 +165,11 @@ std::string Timer::GetTimeFormatted() {
 #ifdef _WIN32
     struct timeb tp;
     (void)::ftime(&tp);
-    return fmt::format("{}:{:03}", tmp, tp.millitm);
+    return StringFromFormat("%s:%03i", tmp, tp.millitm);
 #else
     struct timeval t;
     (void)gettimeofday(&t, nullptr);
-    return fmt::format("{}:{:03}", tmp, static_cast<int>(t.tv_usec / 1000));
+    return StringFromFormat("%s:%03d", tmp, (int)(t.tv_usec / 1000));
 #endif
 }
 

src/core/core_timing.h

@@ -23,8 +23,6 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 
-namespace CoreTiming {
-
 // The below clock rate is based on Switch's clockspeed being widely known as 1.020GHz
 // The exact value used is of course unverified.
 constexpr u64 BASE_CLOCK_RATE = 1019215872; // Switch clock speed is 1020MHz un/docked
@@ -119,6 +117,8 @@ inline u64 cyclesToMs(s64 cycles) {
     return cycles * 1000 / BASE_CLOCK_RATE;
 }
 
+namespace CoreTiming {
+
 /**
  * CoreTiming begins at the boundary of timing slice -1. An initial call to Advance() is
  * required to end slice -1 and start slice 0 before the first cycle of code is executed.

src/core/hle/kernel/svc.cpp

@@ -510,7 +510,7 @@ static void ExitProcess() {
 /// Creates a new thread
 static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, VAddr stack_top,
                                u32 priority, s32 processor_id) {
-    std::string name = fmt::format("unknown-{:X}", entry_point);
+    std::string name = Common::StringFromFormat("unknown-%llx", entry_point);
 
     if (priority > THREADPRIO_LOWEST) {
         return ERR_OUT_OF_RANGE;

src/core/hle/kernel/thread.cpp

@@ -146,8 +146,7 @@ void Thread::WakeAfterDelay(s64 nanoseconds) {
     if (nanoseconds == -1)
         return;
 
-    CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(nanoseconds), ThreadWakeupEventType,
-                              callback_handle);
+    CoreTiming::ScheduleEvent(nsToCycles(nanoseconds), ThreadWakeupEventType, callback_handle);
 }
 
 void Thread::CancelWakeupTimer() {

src/core/hle/kernel/timer.cpp

@@ -57,8 +57,7 @@ void Timer::Set(s64 initial, s64 interval) {
         // Immediately invoke the callback
         Signal(0);
     } else {
-        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(initial), timer_callback_event_type,
-                                  callback_handle);
+        CoreTiming::ScheduleEvent(nsToCycles(initial), timer_callback_event_type, callback_handle);
     }
 }
 
@@ -87,7 +86,7 @@ void Timer::Signal(int cycles_late) {
 
     if (interval_delay != 0) {
         // Reschedule the timer with the interval delay
-        CoreTiming::ScheduleEvent(CoreTiming::nsToCycles(interval_delay) - cycles_late,
+        CoreTiming::ScheduleEvent(nsToCycles(interval_delay) - cycles_late,
                                   timer_callback_event_type, callback_handle);
     }
 }

src/core/hle/service/am/am.cpp

@@ -12,7 +12,6 @@
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
-#include "core/hle/service/set/set.h"
 #include "core/settings.h"
 
 namespace Service::AM {
@@ -538,11 +537,10 @@ void IApplicationFunctions::SetTerminateResult(Kernel::HLERequestContext& ctx) {
 }
 
 void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
-    // TODO(bunnei): This should be configurable
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u64>(Service::Set::LanguageCode::EN_US));
-    NGLOG_DEBUG(Service_AM, "called");
+    rb.Push<u64>(SystemLanguage::English);
+    NGLOG_WARNING(Service_AM, "(STUBBED) called");
 }
 
 void IApplicationFunctions::InitializeGamePlayRecording(Kernel::HLERequestContext& ctx) {

src/core/hle/service/audio/audout_u.cpp

@@ -18,7 +18,7 @@ constexpr u32 sample_rate{48000};
 /// to more audio channels (probably when Docked I guess)
 constexpr u32 audio_channels{2};
 /// TODO(st4rk): find a proper value for the audio_ticks
-constexpr u64 audio_ticks{static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / 500)};
+constexpr u64 audio_ticks{static_cast<u64>(BASE_CLOCK_RATE / 500)};
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:

src/core/hle/service/audio/audren_u.cpp

@@ -12,7 +12,7 @@
 namespace Service::Audio {
 
 /// TODO(bunnei): Find a proper value for the audio_ticks
-constexpr u64 audio_ticks{static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / 200)};
+constexpr u64 audio_ticks{static_cast<u64>(BASE_CLOCK_RATE / 200)};
 
 class IAudioRenderer final : public ServiceFramework<IAudioRenderer> {
 public:

src/core/hle/service/hid/hid.cpp

@@ -18,9 +18,9 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // TODO(shinyquagsire23): These need better values.
-constexpr u64 pad_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
-constexpr u64 accelerometer_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
-constexpr u64 gyroscope_update_ticks = CoreTiming::BASE_CLOCK_RATE / 10000;
+constexpr u64 pad_update_ticks = BASE_CLOCK_RATE / 10000;
+constexpr u64 accelerometer_update_ticks = BASE_CLOCK_RATE / 10000;
+constexpr u64 gyroscope_update_ticks = BASE_CLOCK_RATE / 10000;
 
 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -19,7 +19,7 @@
 namespace Service::NVFlinger {
 
 constexpr size_t SCREEN_REFRESH_RATE = 60;
-constexpr u64 frame_ticks = static_cast<u64>(CoreTiming::BASE_CLOCK_RATE / SCREEN_REFRESH_RATE);
+constexpr u64 frame_ticks = static_cast<u64>(BASE_CLOCK_RATE / SCREEN_REFRESH_RATE);
 
 NVFlinger::NVFlinger() {
     // Add the different displays to the list of displays.

src/core/hle/service/service.cpp

@@ -58,9 +58,10 @@ static std::string MakeFunctionString(const char* name, const char* port_name,
     // Number of params == bits 0-5 + bits 6-11
     int num_params = (cmd_buff[0] & 0x3F) + ((cmd_buff[0] >> 6) & 0x3F);
 
-    std::string function_string = fmt::format("function '{}': port={}", name, port_name);
+    std::string function_string =
+        Common::StringFromFormat("function '%s': port=%s", name, port_name);
     for (int i = 1; i <= num_params; ++i) {
-        function_string += fmt::format(", cmd_buff[{}]={:#X}", i, cmd_buff[i]);
+        function_string += Common::StringFromFormat(", cmd_buff[%i]=0x%X", i, cmd_buff[i]);
     }
     return function_string;
 }

src/core/hle/service/set/set.cpp

@@ -12,33 +12,19 @@
 namespace Service::Set {
 
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
+    static constexpr std::array<std::array<char, 8>, 17> language_codes = {
+        {"ja", "en-US", "fr", "de", "it", "es", "zh-CN", "ko", "nl", "pt", "pt-BR" "ru", "zh-TW", "en-GB",
+         "fr-CA", "es-419", "zh-Hans", "zh-Hant"}};
+
     IPC::RequestParser rp{ctx};
     u32 id = rp.Pop<u32>();
+    constexpr std::array<u8, 13> lang_codes{};
 
-    static constexpr std::array<LanguageCode, 17> available_language_codes = {{
-        LanguageCode::JA,
-        LanguageCode::EN_US,
-        LanguageCode::FR,
-        LanguageCode::DE,
-        LanguageCode::IT,
-        LanguageCode::ES,
-        LanguageCode::ZH_CN,
-        LanguageCode::KO,
-        LanguageCode::NL,
-        LanguageCode::PT,
-        LanguageCode::RU,
-        LanguageCode::ZH_TW,
-        LanguageCode::EN_GB,
-        LanguageCode::FR_CA,
-        LanguageCode::ES_419,
-        LanguageCode::ZH_HANS,
-        LanguageCode::ZH_HANT,
-    }};
-    ctx.WriteBuffer(available_language_codes.data(), available_language_codes.size());
+    ctx.WriteBuffer(language_codes.data(), language_codes.size());
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
-    rb.Push(static_cast<u64>(available_language_codes.size()));
+    rb.Push(language_codes.size());
 
     NGLOG_DEBUG(Service_SET, "called");
 }

src/core/hle/service/set/set.h

@@ -8,27 +8,6 @@
 
 namespace Service::Set {
 
-/// This is "nn::settings::LanguageCode", which is a NUL-terminated string stored in a u64.
-enum class LanguageCode : u64 {
-    JA = 0x000000000000616A,
-    EN_US = 0x00000053552D6E65,
-    FR = 0x0000000000007266,
-    DE = 0x0000000000006564,
-    IT = 0x0000000000007469,
-    ES = 0x0000000000007365,
-    ZH_CN = 0x0000004E432D687A,
-    KO = 0x0000000000006F6B,
-    NL = 0x0000000000006C6E,
-    PT = 0x0000000000007470,
-    RU = 0x0000000000007572,
-    ZH_TW = 0x00000057542D687A,
-    EN_GB = 0x00000042472D6E65,
-    FR_CA = 0x00000041432D7266,
-    ES_419 = 0x00003931342D7365,
-    ZH_HANS = 0x00736E61482D687A,
-    ZH_HANT = 0x00746E61482D687A,
-};
-
 class SET final : public ServiceFramework<SET> {
 public:
     explicit SET();

src/core/hle/service/time/time.cpp

@@ -59,8 +59,7 @@ public:
 private:
     void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
         NGLOG_DEBUG(Service_Time, "called");
-        SteadyClockTimePoint steady_clock_time_point{
-            CoreTiming::cyclesToMs(CoreTiming::GetTicks()) / 1000};
+        SteadyClockTimePoint steady_clock_time_point{cyclesToMs(CoreTiming::GetTicks()) / 1000};
         IPC::ResponseBuilder rb{ctx, (sizeof(SteadyClockTimePoint) / 4) + 2};
         rb.Push(RESULT_SUCCESS);
         rb.PushRaw(steady_clock_time_point);

src/core/hle/shared_page.cpp

@@ -56,14 +56,13 @@ static void UpdateTimeCallback(u64 userdata, int cycles_late) {
 
     date_time.date_time = GetSystemTime();
     date_time.update_tick = CoreTiming::GetTicks();
-    date_time.tick_to_second_coefficient = CoreTiming::BASE_CLOCK_RATE;
+    date_time.tick_to_second_coefficient = BASE_CLOCK_RATE;
     date_time.tick_offset = 0;
 
     ++shared_page.date_time_counter;
 
     // system time is updated hourly
-    CoreTiming::ScheduleEvent(CoreTiming::msToCycles(60 * 60 * 1000) - cycles_late,
-                              update_time_event);
+    CoreTiming::ScheduleEvent(msToCycles(60 * 60 * 1000) - cycles_late, update_time_event);
 }
 
 void Init() {

src/video_core/engines/fermi_2d.cpp

@@ -59,12 +59,12 @@ void Fermi2D::HandleSurfaceCopy() {
         // If the input is tiled and the output is linear, deswizzle the input and copy it over.
         Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
                                   dst_bytes_per_pixel, src_buffer, dst_buffer, true,
-                                  regs.src.BlockHeight());
+                                  regs.src.block_height);
     } else {
         // If the input is linear and the output is tiled, swizzle the input and copy it over.
         Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
                                   dst_bytes_per_pixel, dst_buffer, src_buffer, false,
-                                  regs.dst.BlockHeight());
+                                  regs.dst.block_height);
     }
 }
 

src/video_core/engines/fermi_2d.h

@@ -49,11 +49,6 @@ public:
                 return static_cast<GPUVAddr>((static_cast<GPUVAddr>(address_high) << 32) |
                                              address_low);
             }
-
-            u32 BlockHeight() const {
-                // The block height is stored in log2 format.
-                return 1 << block_height;
-            }
         };
         static_assert(sizeof(Surface) == 0x28, "Surface has incorrect size");
 

src/video_core/engines/maxwell_3d.cpp

@@ -208,16 +208,6 @@ void Maxwell3D::DrawArrays() {
 
     const bool is_indexed{regs.index_array.count && !regs.vertex_buffer.count};
     VideoCore::g_renderer->Rasterizer()->AccelerateDrawBatch(is_indexed);
-
-    // TODO(bunnei): Below, we reset vertex count so that we can use these registers to determine if
-    // the game is trying to draw indexed or direct mode. This needs to be verified on HW still -
-    // it's possible that it is incorrect and that there is some other register used to specify the
-    // drawing mode.
-    if (is_indexed) {
-        regs.index_array.count = 0;
-    } else {
-        regs.vertex_buffer.count = 0;
-    }
 }
 
 void Maxwell3D::ProcessCBBind(Regs::ShaderStage stage) {

src/video_core/engines/shader_bytecode.h

@@ -25,13 +25,6 @@ struct Register {
     /// Register 255 is special cased to always be 0
     static constexpr size_t ZeroIndex = 255;
 
-    enum class Size : u64 {
-        Byte = 0,
-        Short = 1,
-        Word = 2,
-        Long = 3,
-    };
-
     constexpr Register() = default;
 
     constexpr Register(u64 value) : value(value) {}
@@ -243,15 +236,6 @@ union Instruction {
         BitField<56, 1, u64> neg_imm;
     } fset;
 
-    union {
-        BitField<10, 2, Register::Size> size;
-        BitField<13, 1, u64> is_signed;
-        BitField<41, 2, u64> selector;
-        BitField<45, 1, u64> negate_a;
-        BitField<49, 1, u64> abs_a;
-        BitField<50, 1, u64> saturate_a;
-    } conversion;
-
     BitField<61, 1, u64> is_b_imm;
     BitField<60, 1, u64> is_b_gpr;
     BitField<59, 1, u64> is_c_gpr;
@@ -306,11 +290,10 @@ public:
         MOV_C,
         MOV_R,
         MOV_IMM,
-        MOV32_IMM,
+        MOV32I,
         SHR_C,
         SHR_R,
         SHR_IMM,
-        FMNMX,
         FSETP_C, // Set Predicate
         FSETP_R,
         FSETP_IMM,
@@ -331,7 +314,6 @@ public:
         FloatSet,
         FloatSetPredicate,
         IntegerSetPredicate,
-        Conversion,
         Unknown,
     };
 
@@ -453,21 +435,20 @@ private:
             INST("0100110010110---", Id::F2I_C, Type::Arithmetic, "F2I_C"),
             INST("0101110010110---", Id::F2I_R, Type::Arithmetic, "F2I_R"),
             INST("0011100-10110---", Id::F2I_IMM, Type::Arithmetic, "F2I_IMM"),
+            INST("0100110010111---", Id::I2F_C, Type::Arithmetic, "I2F_C"),
+            INST("0101110010111---", Id::I2F_R, Type::Arithmetic, "I2F_R"),
+            INST("0011100-10111---", Id::I2F_IMM, Type::Arithmetic, "I2F_IMM"),
+            INST("0100110011100---", Id::I2I_C, Type::Arithmetic, "I2I_C"),
+            INST("0101110011100---", Id::I2I_R, Type::Arithmetic, "I2I_R"),
+            INST("01110001-1000---", Id::I2I_IMM, Type::Arithmetic, "I2I_IMM"),
             INST("000001----------", Id::LOP32I, Type::Arithmetic, "LOP32I"),
             INST("0100110010011---", Id::MOV_C, Type::Arithmetic, "MOV_C"),
             INST("0101110010011---", Id::MOV_R, Type::Arithmetic, "MOV_R"),
             INST("0011100-10011---", Id::MOV_IMM, Type::Arithmetic, "MOV_IMM"),
-            INST("000000010000----", Id::MOV32_IMM, Type::Arithmetic, "MOV32_IMM"),
+            INST("000000010000----", Id::MOV32I, Type::Arithmetic, "MOV32I"),
             INST("0100110000101---", Id::SHR_C, Type::Arithmetic, "SHR_C"),
             INST("0101110000101---", Id::SHR_R, Type::Arithmetic, "SHR_R"),
             INST("0011100-00101---", Id::SHR_IMM, Type::Arithmetic, "SHR_IMM"),
-            INST("0101110001100---", Id::FMNMX, Type::Arithmetic, "FMNMX"),
-            INST("0100110011100---", Id::I2I_C, Type::Conversion, "I2I_C"),
-            INST("0101110011100---", Id::I2I_R, Type::Conversion, "I2I_R"),
-            INST("01110001-1000---", Id::I2I_IMM, Type::Conversion, "I2I_IMM"),
-            INST("0100110010111---", Id::I2F_C, Type::Conversion, "I2F_C"),
-            INST("0101110010111---", Id::I2F_R, Type::Conversion, "I2F_R"),
-            INST("0011100-10111---", Id::I2F_IMM, Type::Conversion, "I2F_IMM"),
             INST("01011000--------", Id::FSET_R, Type::FloatSet, "FSET_R"),
             INST("0100100---------", Id::FSET_C, Type::FloatSet, "FSET_C"),
             INST("0011000---------", Id::FSET_IMM, Type::FloatSet, "FSET_IMM"),

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -153,61 +153,85 @@ private:
  */
 class GLSLRegister {
 public:
-    enum class Type {
-        Float,
-        Integer,
-        UnsignedInteger,
-    };
+    GLSLRegister(size_t index, ShaderWriter& shader)
+        : index{index}, shader{shader}, float_str{"freg_" + std::to_string(index)},
+          integer_str{"ireg_" + std::to_string(index)} {}
 
-    GLSLRegister(size_t index, ShaderWriter& shader) : index{index}, shader{shader} {}
+    /// Returns a GLSL string representing the current state of the register
+    const std::string& GetActiveString() {
+        declr_type.insert(active_type);
 
-    /// Gets the GLSL type string for a register
-    static std::string GetTypeString(Type type) {
-        switch (type) {
+        switch (active_type) {
         case Type::Float:
-            return "float";
+            return float_str;
         case Type::Integer:
-            return "int";
-        case Type::UnsignedInteger:
-            return "uint";
+            return integer_str;
         }
 
         UNREACHABLE();
-        return {};
+        return float_str;
     }
 
-    /// Gets the GLSL register prefix string, used for declarations and referencing
-    static std::string GetPrefixString(Type type) {
-        return "reg_" + GetTypeString(type) + '_';
+    /// Returns a GLSL string representing the register as a float
+    const std::string& GetFloatString() const {
+        ASSERT(IsFloatUsed());
+        return float_str;
     }
 
-    /// Returns a GLSL string representing the current state of the register
-    const std::string GetActiveString() {
-        declr_type.insert(active_type);
-        return GetPrefixString(active_type) + std::to_string(index);
+    /// Returns a GLSL string representing the register as an integer
+    const std::string& GetIntegerString() const {
+        ASSERT(IsIntegerUsed());
+        return integer_str;
     }
 
-    /// Returns true if the active type is a float
+    /// Convert the current register state from float to integer
+    void FloatToInteger() {
+        ASSERT(active_type == Type::Float);
+
+        const std::string src = GetActiveString();
+        active_type = Type::Integer;
+        const std::string dest = GetActiveString();
+
+        shader.AddLine(dest + " = floatBitsToInt(" + src + ");");
+    }
+
+    /// Convert the current register state from integer to float
+    void IntegerToFloat() {
+        ASSERT(active_type == Type::Integer);
+
+        const std::string src = GetActiveString();
+        active_type = Type::Float;
+        const std::string dest = GetActiveString();
+
+        shader.AddLine(dest + " = intBitsToFloat(" + src + ");");
+    }
+
+    /// Returns true if the register was ever used as a float, used for register declarations
+    bool IsFloatUsed() const {
+        return declr_type.find(Type::Float) != declr_type.end();
+    }
+
+    /// Returns true if the register was ever used as an integer, used for register declarations
+    bool IsIntegerUsed() const {
+        return declr_type.find(Type::Integer) != declr_type.end();
+    }
+
+    /// Returns true if the active type is float
     bool IsFloat() const {
         return active_type == Type::Float;
     }
 
-    /// Returns true if the active type is an integer
+    /// Returns true if the active type is integer
     bool IsInteger() const {
         return active_type == Type::Integer;
     }
 
-    /// Returns the index of the register
-    size_t GetIndex() const {
-        return index;
-    }
-
-    /// Returns a set of the declared types of the register
-    const std::set<Type>& DeclaredTypes() const {
-        return declr_type;
-    }
-
 private:
+    enum class Type {
+        Float,
+        Integer,
+    };
+
     const size_t index;
     const std::string float_str;
     const std::string integer_str;
@@ -230,35 +254,18 @@ public:
         BuildRegisterList();
     }
 
-    /**
-     * Gets a register as an float.
-     * @param reg The register to get.
-     * @param elem The element to use for the operation.
-     * @returns GLSL string corresponding to the register as a float.
-     */
-    std::string GetRegisterAsFloat(const Register& reg, unsigned elem = 0) {
-        ASSERT(regs[reg].IsFloat());
-        return GetRegister(reg, elem);
+    /// Generates code representing a temporary (GPR) register.
+    std::string GetRegister(const Register& reg, unsigned elem = 0) {
+        if (reg == Register::ZeroIndex) {
+            return "0";
+        }
+
+        return regs[reg.GetSwizzledIndex(elem)].GetActiveString();
     }
 
     /**
-     * Gets a register as an integer.
-     * @param reg The register to get.
-     * @param elem The element to use for the operation.
-     * @param is_signed Whether to get the register as a signed (or unsigned) integer.
-     * @returns GLSL string corresponding to the register as an integer.
-     */
-    std::string GetRegisterAsInteger(const Register& reg, unsigned elem = 0,
-                                     bool is_signed = true) {
-        const std::string func = GetGLSLConversionFunc(
-            GLSLRegister::Type::Float,
-            is_signed ? GLSLRegister::Type::Integer : GLSLRegister::Type::UnsignedInteger);
-
-        return func + '(' + GetRegister(reg, elem) + ')';
-    }
-
-    /**
-     * Writes code that does a register assignment to float value operation.
+     * Writes code that does a register assignment to float value operation. Should only be used
+     * with shader instructions that deal with floats.
      * @param reg The destination register to use.
      * @param elem The element to use for the operation.
      * @param value The code representing the value to assign.
@@ -270,28 +277,21 @@ public:
     void SetRegisterToFloat(const Register& reg, u64 elem, const std::string& value,
                             u64 dest_num_components, u64 value_num_components, bool is_abs = false,
                             u64 dest_elem = 0) {
-        SetRegister(reg, elem, value, dest_num_components, value_num_components, is_abs, dest_elem);
-    }
+        ASSERT(regs[reg].IsFloat());
 
-    /**
-     * Writes code that does a register assignment to integer value operation.
-     * @param reg The destination register to use.
-     * @param elem The element to use for the operation.
-     * @param value The code representing the value to assign.
-     * @param dest_num_components Number of components in the destination.
-     * @param value_num_components Number of components in the value.
-     * @param is_abs Optional, when True, applies absolute value to output.
-     * @param dest_elem Optional, the destination element to use for the operation.
-     */
-    void SetRegisterToInteger(const Register& reg, bool is_signed, u64 elem,
-                              const std::string& value, u64 dest_num_components,
-                              u64 value_num_components, bool is_abs = false, u64 dest_elem = 0) {
-        const std::string func = GetGLSLConversionFunc(
-            is_signed ? GLSLRegister::Type::Integer : GLSLRegister::Type::UnsignedInteger,
-            GLSLRegister::Type::Float);
+        std::string dest = GetRegister(reg, dest_elem);
+        if (dest_num_components > 1) {
+            dest += GetSwizzle(elem);
+        }
 
-        SetRegister(reg, elem, func + '(' + value + ')', dest_num_components, value_num_components,
-                    is_abs, dest_elem);
+        std::string src = '(' + value + ')';
+        if (value_num_components > 1) {
+            src += GetSwizzle(elem);
+        }
+
+        src = is_abs ? "abs(" + src + ')' : src;
+
+        shader.AddLine(dest + " = " + src + ';');
     }
 
     /**
@@ -302,7 +302,7 @@ public:
      * @param attribute The input attibute to use as the source value.
      */
     void SetRegisterToInputAttibute(const Register& reg, u64 elem, Attribute::Index attribute) {
-        std::string dest = GetRegisterAsFloat(reg);
+        std::string dest = GetRegister(reg);
         std::string src = GetInputAttribute(attribute) + GetSwizzle(elem);
 
         if (regs[reg].IsFloat()) {
@@ -323,7 +323,7 @@ public:
      */
     void SetOutputAttributeToRegister(Attribute::Index attribute, u64 elem, const Register& reg) {
         std::string dest = GetOutputAttribute(attribute) + GetSwizzle(elem);
-        std::string src = GetRegisterAsFloat(reg);
+        std::string src = GetRegister(reg);
         ASSERT_MSG(regs[reg].IsFloat(), "Output attributes must be set to a float");
         shader.AddLine(dest + " = " + src + ';');
     }
@@ -347,10 +347,11 @@ public:
     /// Add declarations for registers
     void GenerateDeclarations() {
         for (const auto& reg : regs) {
-            for (const auto& type : reg.DeclaredTypes()) {
-                declarations.AddLine(GLSLRegister::GetTypeString(type) + ' ' +
-                                     GLSLRegister::GetPrefixString(type) +
-                                     std::to_string(reg.GetIndex()) + " = 0;");
+            if (reg.IsFloatUsed()) {
+                declarations.AddLine("float " + reg.GetFloatString() + " = 0.0;");
+            }
+            if (reg.IsIntegerUsed()) {
+                declarations.AddLine("int " + reg.GetIntegerString() + " = 0;");
             }
         }
         declarations.AddNewLine();
@@ -394,51 +395,6 @@ public:
     }
 
 private:
-    /// Build GLSL conversion function, e.g. floatBitsToInt, intBitsToFloat, etc.
-    const std::string GetGLSLConversionFunc(GLSLRegister::Type src, GLSLRegister::Type dest) const {
-        const std::string src_type = GLSLRegister::GetTypeString(src);
-        std::string dest_type = GLSLRegister::GetTypeString(dest);
-        dest_type[0] = toupper(dest_type[0]);
-        return src_type + "BitsTo" + dest_type;
-    }
-
-    /// Generates code representing a temporary (GPR) register.
-    std::string GetRegister(const Register& reg, unsigned elem) {
-        if (reg == Register::ZeroIndex) {
-            return "0";
-        }
-
-        return regs[reg.GetSwizzledIndex(elem)].GetActiveString();
-    }
-
-    /**
-     * Writes code that does a register assignment to value operation.
-     * @param reg The destination register to use.
-     * @param elem The element to use for the operation.
-     * @param value The code representing the value to assign.
-     * @param dest_num_components Number of components in the destination.
-     * @param value_num_components Number of components in the value.
-     * @param is_abs Optional, when True, applies absolute value to output.
-     * @param dest_elem Optional, the destination element to use for the operation.
-     */
-    void SetRegister(const Register& reg, u64 elem, const std::string& value,
-                     u64 dest_num_components, u64 value_num_components, bool is_abs,
-                     u64 dest_elem) {
-        std::string dest = GetRegister(reg, dest_elem);
-        if (dest_num_components > 1) {
-            dest += GetSwizzle(elem);
-        }
-
-        std::string src = '(' + value + ')';
-        if (value_num_components > 1) {
-            src += GetSwizzle(elem);
-        }
-
-        src = is_abs ? "abs(" + src + ')' : src;
-
-        shader.AddLine(dest + " = " + src + ';');
-    }
-
     /// Build the GLSL register list.
     void BuildRegisterList() {
         for (size_t index = 0; index < Register::NumRegisters; ++index) {
@@ -642,7 +598,7 @@ private:
         switch (opcode->GetType()) {
         case OpCode::Type::Arithmetic: {
             std::string op_a = instr.alu.negate_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            op_a += regs.GetRegister(instr.gpr8);
             if (instr.alu.abs_a) {
                 op_a = "abs(" + op_a + ')';
             }
@@ -653,7 +609,7 @@ private:
                 op_b += GetImmediate19(instr);
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b += regs.GetRegister(instr.gpr20);
                 } else {
                     op_b += regs.GetUniform(instr.uniform, instr.gpr0);
                 }
@@ -664,17 +620,6 @@ private:
             }
 
             switch (opcode->GetId()) {
-            case OpCode::Id::MOV_C:
-            case OpCode::Id::MOV_R: {
-                regs.SetRegisterToFloat(instr.gpr0, 0, op_b, 1, 1);
-                break;
-            }
-
-            case OpCode::Id::MOV32_IMM: {
-                // mov32i doesn't have abs or neg bits.
-                regs.SetRegisterToFloat(instr.gpr0, 0, GetImmediate32(instr), 1, 1);
-                break;
-            }
             case OpCode::Id::FMUL_C:
             case OpCode::Id::FMUL_R:
             case OpCode::Id::FMUL_IMM: {
@@ -684,8 +629,8 @@ private:
             case OpCode::Id::FMUL32_IMM: {
                 // fmul32i doesn't have abs or neg bits.
                 regs.SetRegisterToFloat(
-                    instr.gpr0, 0,
-                    regs.GetRegisterAsFloat(instr.gpr8) + " * " + GetImmediate32(instr), 1, 1);
+                    instr.gpr0, 0, regs.GetRegister(instr.gpr8) + " * " + GetImmediate32(instr), 1,
+                    1);
                 break;
             }
             case OpCode::Id::FADD_C:
@@ -742,29 +687,29 @@ private:
             break;
         }
         case OpCode::Type::Ffma: {
-            std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
+            std::string op_a = regs.GetRegister(instr.gpr8);
             std::string op_b = instr.ffma.negate_b ? "-" : "";
             std::string op_c = instr.ffma.negate_c ? "-" : "";
 
             switch (opcode->GetId()) {
             case OpCode::Id::FFMA_CR: {
                 op_b += regs.GetUniform(instr.uniform, instr.gpr0);
-                op_c += regs.GetRegisterAsFloat(instr.gpr39);
+                op_c += regs.GetRegister(instr.gpr39);
                 break;
             }
             case OpCode::Id::FFMA_RR: {
-                op_b += regs.GetRegisterAsFloat(instr.gpr20);
-                op_c += regs.GetRegisterAsFloat(instr.gpr39);
+                op_b += regs.GetRegister(instr.gpr20);
+                op_c += regs.GetRegister(instr.gpr39);
                 break;
             }
             case OpCode::Id::FFMA_RC: {
-                op_b += regs.GetRegisterAsFloat(instr.gpr39);
+                op_b += regs.GetRegister(instr.gpr39);
                 op_c += regs.GetUniform(instr.uniform, instr.gpr0);
                 break;
             }
             case OpCode::Id::FFMA_IMM: {
                 op_b += GetImmediate19(instr);
-                op_c += regs.GetRegisterAsFloat(instr.gpr39);
+                op_c += regs.GetRegister(instr.gpr39);
                 break;
             }
             default: {
@@ -776,32 +721,6 @@ private:
             regs.SetRegisterToFloat(instr.gpr0, 0, op_a + " * " + op_b + " + " + op_c, 1, 1);
             break;
         }
-        case OpCode::Type::Conversion: {
-            ASSERT_MSG(instr.conversion.size == Register::Size::Word, "Unimplemented");
-            ASSERT_MSG(!instr.conversion.selector, "Unimplemented");
-            ASSERT_MSG(!instr.conversion.negate_a, "Unimplemented");
-            ASSERT_MSG(!instr.conversion.saturate_a, "Unimplemented");
-
-            switch (opcode->GetId()) {
-            case OpCode::Id::I2I_R:
-            case OpCode::Id::I2F_R: {
-                std::string op_a =
-                    regs.GetRegisterAsInteger(instr.gpr20, 0, instr.conversion.is_signed);
-
-                if (instr.conversion.abs_a) {
-                    op_a = "abs(" + op_a + ')';
-                }
-
-                regs.SetRegisterToInteger(instr.gpr0, instr.conversion.is_signed, 0, op_a, 1, 1);
-                break;
-            }
-            default: {
-                NGLOG_CRITICAL(HW_GPU, "Unhandled conversion instruction: {}", opcode->GetName());
-                UNREACHABLE();
-            }
-            }
-            break;
-        }
         case OpCode::Type::Memory: {
             const Attribute::Index attribute = instr.attribute.fmt20.index;
 
@@ -820,8 +739,8 @@ private:
             }
             case OpCode::Id::TEXS: {
                 ASSERT_MSG(instr.attribute.fmt20.size == 4, "untested");
-                const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
-                const std::string op_b = regs.GetRegisterAsFloat(instr.gpr20);
+                const std::string op_a = regs.GetRegister(instr.gpr8);
+                const std::string op_b = regs.GetRegister(instr.gpr20);
                 const std::string sampler = GetSampler(instr.sampler);
                 const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
                 // Add an extra scope and declare the texture coords inside to prevent overwriting
@@ -846,7 +765,7 @@ private:
         }
         case OpCode::Type::FloatSetPredicate: {
             std::string op_a = instr.fsetp.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            op_a += regs.GetRegister(instr.gpr8);
 
             if (instr.fsetp.abs_a) {
                 op_a = "abs(" + op_a + ')';
@@ -862,7 +781,7 @@ private:
                 op_b += '(' + GetImmediate19(instr) + ')';
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b += regs.GetRegister(instr.gpr20);
                 } else {
                     op_b += regs.GetUniform(instr.uniform, instr.gpr0);
                 }
@@ -888,9 +807,6 @@ private:
             case PredCondition::Equal:
                 SetPredicate(instr.fsetp.pred3, '(' + op_a + ") == (" + op_b + ')');
                 break;
-            case PredCondition::LessEqual:
-                SetPredicate(instr.fsetp.pred3, '(' + op_a + ") <= (" + op_b + ')');
-                break;
             default:
                 NGLOG_CRITICAL(HW_GPU, "Unhandled predicate condition: {} (a: {}, b: {})",
                                static_cast<unsigned>(instr.fsetp.cond.Value()), op_a, op_b);
@@ -900,7 +816,7 @@ private:
         }
         case OpCode::Type::FloatSet: {
             std::string op_a = instr.fset.neg_a ? "-" : "";
-            op_a += regs.GetRegisterAsFloat(instr.gpr8);
+            op_a += regs.GetRegister(instr.gpr8);
 
             if (instr.fset.abs_a) {
                 op_a = "abs(" + op_a + ')';
@@ -916,7 +832,7 @@ private:
                     op_b += imm;
             } else {
                 if (instr.is_b_gpr) {
-                    op_b += regs.GetRegisterAsFloat(instr.gpr20);
+                    op_b += regs.GetRegister(instr.gpr20);
                 } else {
                     op_b += regs.GetUniform(instr.uniform, instr.gpr0);
                 }
@@ -942,10 +858,6 @@ private:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         "((" + op_a + ") == (" + op_b + ")) ? 1.0 : 0", 1, 1);
                 break;
-            case PredCondition::LessEqual:
-                regs.SetRegisterToFloat(instr.gpr0, 0,
-                                        "((" + op_a + ") <= (" + op_b + ")) ? 1.0 : 0", 1, 1);
-                break;
             case PredCondition::GreaterThan:
                 regs.SetRegisterToFloat(instr.gpr0, 0,
                                         "((" + op_a + ") > (" + op_b + ")) ? 1.0 : 0", 1, 1);
@@ -965,10 +877,10 @@ private:
 
                 // Final color output is currently hardcoded to GPR0-3 for fragment shaders
                 if (stage == Maxwell3D::Regs::ShaderStage::Fragment) {
-                    shader.AddLine("color.r = " + regs.GetRegisterAsFloat(0) + ';');
-                    shader.AddLine("color.g = " + regs.GetRegisterAsFloat(1) + ';');
-                    shader.AddLine("color.b = " + regs.GetRegisterAsFloat(2) + ';');
-                    shader.AddLine("color.a = " + regs.GetRegisterAsFloat(3) + ';');
+                    shader.AddLine("color.r = " + regs.GetRegister(0) + ';');
+                    shader.AddLine("color.g = " + regs.GetRegister(1) + ';');
+                    shader.AddLine("color.b = " + regs.GetRegister(2) + ';');
+                    shader.AddLine("color.a = " + regs.GetRegister(3) + ';');
                 }
 
                 shader.AddLine("return true;");

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -36,18 +36,6 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
         return {};
     }
 
-    case Maxwell::VertexAttribute::Type::SignedNorm: {
-
-        switch (attrib.size) {
-        case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
-            return GL_BYTE;
-        }
-
-        NGLOG_CRITICAL(Render_OpenGL, "Unimplemented vertex size={}", attrib.SizeString());
-        UNREACHABLE();
-        return {};
-    }
-
     case Maxwell::VertexAttribute::Type::Float:
         return GL_FLOAT;
     }

src/yuzu/bootmanager.cpp

@@ -4,8 +4,6 @@
 #include <QScreen>
 #include <QWindow>
 
-#include <fmt/format.h>
-
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "common/string_util.h"
@@ -104,8 +102,8 @@ private:
 GRenderWindow::GRenderWindow(QWidget* parent, EmuThread* emu_thread)
     : QWidget(parent), child(nullptr), emu_thread(emu_thread) {
 
-    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_name,
-                                           Common::g_scm_branch, Common::g_scm_desc);
+    std::string window_title = Common::StringFromFormat("yuzu %s| %s-%s", Common::g_build_name,
+                                                        Common::g_scm_branch, Common::g_scm_desc);
     setWindowTitle(QString::fromStdString(window_title));
 
     InputCommon::Init();

src/yuzu_cmd/emu_window/emu_window_sdl2.cpp

@@ -7,7 +7,6 @@
 #include <string>
 #define SDL_MAIN_HANDLED
 #include <SDL.h>
-#include <fmt/format.h>
 #include <glad/glad.h>
 #include "common/logging/log.h"
 #include "common/scm_rev.h"
@@ -98,8 +97,8 @@ EmuWindow_SDL2::EmuWindow_SDL2(bool fullscreen) {
     SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
     SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0);
 
-    std::string window_title = fmt::format("yuzu {} | {}-{}", Common::g_build_name,
-                                           Common::g_scm_branch, Common::g_scm_desc);
+    std::string window_title = Common::StringFromFormat("yuzu %s| %s-%s ", Common::g_build_name,
+                                                        Common::g_scm_branch, Common::g_scm_desc);
     render_window =
         SDL_CreateWindow(window_title.c_str(),
                          SDL_WINDOWPOS_UNDEFINED, // x position