From 77f3da59914ae1e81b4987837840e139cefa7f6e Mon Sep 17 00:00:00 2001 From: Dominik Date: Fri, 1 Sep 2023 22:28:22 +0200 Subject: [PATCH 01/40] Update pl_PL.ini More work on Polish translation as well as more minor changes & fixes. --- assets/lang/pl_PL.ini | 52 +++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/assets/lang/pl_PL.ini b/assets/lang/pl_PL.ini index 5b21ec0df7..fc9cec0be7 100644 --- a/assets/lang/pl_PL.ini +++ b/assets/lang/pl_PL.ini @@ -20,8 +20,8 @@ Customize = Dostosuj Earned = Zdobyłeś %d z %d osiągnięć i %d z %d punktów Encore Mode = Encore Mode Failed logging in to RetroAchievements = Logowanie do RetroAchievements nieudane -Failed to connect to RetroAchievements. Achievements will not unlock. = Failed to connect to RetroAchievements. Achievements will not unlock. -Failed to identify game. Achievements will not unlock. = Failed to identify game. Achievements will not unlock. +Failed to connect to RetroAchievements. Achievements will not unlock. = Łączenie z serwerem RetroAchievements nieudane. Osiągnięcia nie będą odblokowywane. +Failed to identify game. Achievements will not unlock. = Identyfikacja gry nieudana. Osiągnięcia nie będą odblokowywane. How to use RetroAchievements = Jak używać RetroAchievements In Encore mode - listings may be wrong below = In Encore mode - listings may be wrong below Leaderboard attempt started or failed = Leaderboard attempt started or failed @@ -36,21 +36,21 @@ Log bad memory accesses = Rejestruj złe dostępy do pamięci Mastered %1 = Wymaksowane %1 Notifications = Powiadomiemia Recently unlocked achievements = Ostatnio odblokowane osiągnięcia -Reconnected to RetroAchievements. = Reconnected to RetroAchievements. +Reconnected to RetroAchievements. = Połączono ponownie z RetroAchievements. Register on www.retroachievements.org = Zarejestruj się na www.retroachievements.org RetroAchievements are not available for this game = Usługa RetroAchievements nie jest dostępna dla tej gry RetroAchievements website = Strona internetowa RetroAchievements Rich Presence = Rich Presence Save state loaded without achievement data = Save state loaded without achievement data -Save states not available in Challenge Mode = Save states not available in Challenge Mode +Save states not available in Challenge Mode = Zapisy stanu nie są dostępne w Trybie Wyzwania Sound Effects = Efekty dźwiękowe Statistics = Statystyki Submitted %1 for %2 = Submitted %1 for %2 Syncing achievements data... = Synchronizacja osiągnięć... Test Mode = Tryb Testowy -This feature is not available in Challenge Mode = This feature is not available in Challenge Mode -This game has no achievements = Ta gra nie ma osiągnięć -Top players = Top players +This feature is not available in Challenge Mode = Ta funkcja nie jest dostępna w Trybie Wyzwania +This game has no achievements = Ta gra nie posiada osiągnięć +Top players = Najlepsi gracze Unlocked achievements = Odblokowane osiągnięcia Unofficial achievements = Nieoficjalnie osiągnięcia Unsupported achievements = Niewspierane osiągnięcia @@ -109,7 +109,7 @@ Double tap = Dwukrotne dotknięcie Enable analog stick gesture = Enable analog stick gesture Enable gesture control = Włącz kontrolę kestami Enable standard shortcut keys = Włącz standardowe klawisze skrótów -frames = frames +frames = klatki Gesture = Gesty Gesture mapping = Konfiguracja gestów Glowing borders = Świecące krawędzie @@ -147,7 +147,7 @@ Sensitivity (scale) = Czułość (dostosuj) Sensitivity = Czułość Shape = Kształt Show Touch Pause Menu Button = Pokaż dotykowy przycisk Menu Pauzy -Sticky D-Pad (easier sweeping movements) = Sticky D-Pad (easier sweeping movements) +Sticky D-Pad (easier sweeping movements) = Lepki D-Pad (easier sweeping movements) Swipe = Przesunięcie palcem Swipe sensitivity = Czułość przesunięcia Swipe smoothing = Wygładzanie przesunięcia @@ -159,10 +159,10 @@ Tilt Sensitivity along Y axis = Czułość przechyłu wzdłuż osi Y To Calibrate = Trzymaj urządzenie pod preferowanym kątem i naciśnij „Kalibracja”. Toggle mode = Zmień tryb Touch Control Visibility = Kontroler dotykowy (widoczny) -Use custom right analog = Use custom right analog +Use custom right analog = Użyj niestandardowego prawego analoga Use Mouse Control = Włącz kontrolę myszką Visibility = Widoczność -Visible = WIdoczny +Visible = Widoczny X = X Y = Y @@ -281,11 +281,11 @@ Backspace = Backspace Block address = Adres bloku By Address = Po adresie Copy savestates to memstick root = Skopiuj zapisane stany do folderu głównego Karty Pamięci -Create frame dump = Create frame dump +Create frame dump = Stwórz zrzut klatki Create/Open textures.ini file for current game = Stwórz/otwórz plik textures.ini z bieżącej gry Current = Obecny -Debug overlay = Debug overlay -Debug stats = Debug stats +Debug overlay = Nakładka debugowania +Debug stats = Statystyki debugowania Dev Tools = Narzędzia Developerskie DevMenu = Menu deweloperskie Disabled JIT functionality = Wyłącz funkcje JIT @@ -483,7 +483,7 @@ PS1 EBOOTs are not supported by PPSSPP. = Pliki EBOOT PS1 nie są obsługiwane p PSX game image detected. = Plik jest obrazem MODE2. PPSSPP nie obsługuje gier z PS1. RAR file detected (Require UnRAR) = Wykryto plik RAR.\nRozpakuj go przed użyciem (spróbuj UnRAR). RAR file detected (Require WINRAR) = Wykryto plik RAR.\nRozpakuj go przed użyciem (spróbuj WinRAR). -Running slow: try frameskip, sound is choppy when slow = Running slow: try frameskip, sound is choppy when slow +Running slow: Wypróbuj pomijania klatek, dźwięk przerywa gdy emulacja spowalnia = Running slow: try frameskip, sound is choppy when slow Running slow: Try turning off Software Rendering = Running slow: try turning off "software rendering" Running slow: Wolne działanie: spróbuj pomijania klatek, dźwięk zacina przy wolnym działaniu Running slow: Wolne działanie: spróbuj wyłączyć "Renderowanie programowe" @@ -647,7 +647,7 @@ Software Rendering = Renderowanie programowe (wolne) Software Skinning = Programowy skinning SoftwareSkinning Tip = Łączy na CPU wywołania rysujące modele z animacjami, przyspieszenie w większości gier Speed = Prędkość (procentowo) -Speed Hacks = Speed Hacks (powodują problemy) +Speed Hacks = Haki Prędkościowe (powodują problemy) Stereo display shader = Stereoskopowe wyświetlanie shaderów Stereo rendering = Renderowanie stereoskopowe Stretch = Rozciąganie @@ -764,12 +764,12 @@ L = L Left = Strzałka w lewo Load State = Wczytaj stan Mute toggle = Przełącznik wyciszenia -Next Slot = Następny slot +Next Slot = Następny Slot None = Nic Note = Notka OpenChat = Otwórz czat Pause = Pauza -Previous Slot = Previous Slot +Previous Slot = Poprzedni Slot R = R RapidFire = Auto. strzelanie Record = Nagraj @@ -784,7 +784,7 @@ RightAn.Up = Pr. gałk. w górę Rotate Analog (CCW) = Obróć analog (CCW) Rotate Analog (CW) = Obróć analog (CW) Save State = Zapisz stan -Screen = Screen +Screen = Ekran Screenshot = Zrzut ekranu Select = Select SpeedToggle = Zmień prędkość @@ -799,7 +799,7 @@ Texture Dumping = Zrzut tekstur Texture Replacement = Podmiana tekstur Toggle Fullscreen = Wł./wył. pełny ekran Toggle mode = Tryb przełączania -Toggle WLAN = Toggle WLAN +Toggle WLAN = Przełącz WLAN Triangle = Trójkąt Fast-forward = Pełna prędkość Up = Strzałka w górę @@ -809,7 +809,7 @@ Wlan = WLAN [MemStick] Already contains PSP data = Już zawiera dane PSP -Cancelled - try again = Cancelled - try again +Cancelled - try again = Anulowano - spróbuj ponownie Create or Choose a PSP folder = Utwórz lub Wybierz folder PSP Current = Obecny DataCanBeShared = Dane mogą być udostępniane pomiędzy zwykłą wersją PPSSPP, a wersją Gold @@ -870,7 +870,7 @@ Failed to Bind Port = Błąd przy przypisywaniu portu Failed to connect to Adhoc Server = Błąd przy łączeniu z serwerem Ad-Hoc Forced First Connect = Wymuszenie pierwszego połączenie (szybsze łączenie) #GM = Dane z nieznanego portu -GM: Data from Unknown Port = GM: Data from Unknown Port +GM: Data from Unknown Port = GM: Dane z nieznanego portu Hostname = Nazwa hosta Invalid IP or hostname = Niepoprawny adres IP lub nazwa hosta Minimum Timeout = Minimalny czas oczekiwania (podaj w ms, domyślnie 0) @@ -886,7 +886,7 @@ Quick Chat 3 = Szybki czat 3 Quick Chat 4 = Szybki czat 4 Quick Chat 5 = Szybki czat 5 QuickChat = Szybki czat -Randomize = Randomize +Randomize = Losuj Send = Wyślij Send Discord Presence information = Przesyłaj informacje Discord Rich Presence Unable to find UPnP device = Nie udało się zlokalizować urządzenia UPnP @@ -905,7 +905,7 @@ Chinese (traditional) = Chinese (traditional) Dutch = Dutch English = English French = French -Game language = Game language +Game language = Język gry German = German Italian = Italian Japanese = Japanese @@ -1006,7 +1006,7 @@ tools = Wykorzystane narzędzia: # Add translators1-6 for up to 6 lines of translator credits. # Leave extra lines blank. 4 contributors per line seems to look best. translators1 = Daniel Kluz, Michał Kasprzak, Mateusz Godlewski, Łukasz Bereza -translators2 = oop23, Silent, Patrxgt +translators2 = oop23, Silent, Patrxgt, Dominik translators3 = Poprzednią edycję tłumaczenia stworzyli: translators4 = hrydgard, The Dax, mikusp, adrian17 translators5 = @@ -1187,7 +1187,7 @@ OpenGL Extensions = Rozszerzenia OpenGL Optimal frames per buffer = Optymalna ilość klatek na bufor Optimal sample rate = Optymalna częstotliwość próbkowania OS Information = Informacje o OS -Pixel resolution = Pixel resolution +Pixel resolution = Rozdzielczość pixeli PPSSPP build = Kompilacja PPSSPP Present modes = Present modes Refresh rate = Częstotliwość odświeżania From 5459ca0fd058c6831628b24d7db7d0e98f8a0ac2 Mon Sep 17 00:00:00 2001 From: TotalCaesar659 <14265316+TotalCaesar659@users.noreply.github.com> Date: Sat, 2 Sep 2023 00:29:14 +0300 Subject: [PATCH 02/40] Update Russian translation --- assets/lang/ru_RU.ini | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/assets/lang/ru_RU.ini b/assets/lang/ru_RU.ini index f11d0e11b8..4ece8caaa9 100644 --- a/assets/lang/ru_RU.ini +++ b/assets/lang/ru_RU.ini @@ -106,7 +106,7 @@ Deadzone radius = Радиус мертвой зоны Disable D-Pad diagonals (4-way touch) = Отключить крестовину по диагонали Disable diagonal input = Отключить диагональный ввод Double tap = Двойное нажатие -Enable analog stick gesture = Enable analog stick gesture +Enable analog stick gesture = Включить жест аналогового стика Enable gesture control = Включить настройку жестов Enable standard shortcut keys = Включить стандартные сочетания клавиш frames = кадров @@ -147,7 +147,7 @@ Sensitivity (scale) = Чувствительность (шкала) Sensitivity = Чувствительность Shape = Форма Show Touch Pause Menu Button = Показывать кнопку паузы -Sticky D-Pad (easier sweeping movements) = Sticky D-Pad (easier sweeping movements) +Sticky D-Pad (easier sweeping movements) = Прилипающий D-Pad (облегченные масштабные движения) Swipe = Свайпы Swipe sensitivity = Чувствительность свайпов Swipe smoothing = Сглаживание свайпов @@ -284,8 +284,8 @@ Copy savestates to memstick root = Копировать состояния со Create frame dump = Создать дамп кадра Create/Open textures.ini file for current game = Создать/открыть файл textures.ini для текущей игры Current = Текущий -Debug overlay = Debug overlay -Debug stats = Debug stats +Debug overlay = Оверлей отладки +Debug stats = Статистика отладки Dev Tools = Инструменты разработчика DevMenu = Меню разраб. Disabled JIT functionality = Отключение функционала JIT @@ -300,7 +300,7 @@ Fragment = Фрагмент Frame timing = Время кадра Framedump tests = Тест дампов кадров Frame Profiler = Профайлер кадров -GPU Allocator Viewer = GPU Allocator Viewer +GPU Allocator Viewer = Просмотрщик аллокатора ГП GPU Driver Test = Проверка драйвера ГП GPU log profiler = Профилировщик логов ГП GPU Profile = Профиль ГП @@ -313,7 +313,7 @@ Logging Channels = Параметры логирования Multi-threaded rendering = Многопоточный рендеринг Next = Следующий No block = Нет блока -Off = Off +Off = Выкл. Prev = Предыдущий Random = Случайный Replace textures = Подменять текстуры @@ -331,8 +331,8 @@ Stats = Статистика System Information = Информация о системе Texture ini file created = Создан файл textures.ini Texture Replacement = Подмена текстур -Audio Debug = отладку аудио -Control Debug = отладку управления +Audio Debug = Отладка аудио +Control Debug = Отладка управления Toggle Freeze = Запустить/остановить Touchscreen Test = Тест сенсорного экрана Ubershaders = Убершейдеры @@ -375,7 +375,7 @@ Disabled = Отключено Dumps = Дампы Edit = Изменить Enable All = Включить все -Enabled = Enabled +Enabled = Включено Enter = Ввод Failed to connect to server, check your internet connection. = Не удалось подключиться к серверу, проверьте ваше интернет-соединение. Failed to log in, check your username and password. = Не удалось войти, проверьте ваши имя пользователя и пароль. @@ -386,7 +386,7 @@ Grid = Сетка Inactive = Неактивно Installing... = Установка... InternalError = Произошла внутренняя ошибка. -Links = Links +Links = Ссылки Load = Загрузить Load completed = Загрузка завершена Loading = Загрузка\nПожалуйста, подождите... @@ -419,7 +419,7 @@ SavingFailed = Не удалось сохранить. Search = Поиск seconds, 0:off = секунд, 0 = выкл. Select = Выбрать -Settings = Settings +Settings = Настройки Shift = Сдвинуть Skip = Пропустить Snap = Разметка @@ -434,7 +434,7 @@ Top Center = Вверху в центре Top Left = Вверху слева Top Right = Вверу справа Unsupported = Не поддерживается -Username = Username +Username = Имя пользователя When you save, it will load on a PSP, but not an older PPSSPP = Когда вы сохранитесь, оно может быть загружено на PSP, но не на старой версии PPSSPP When you save, it will not work on outdated PSP Firmware anymore = Когда вы сохранитесь, оно больше не будет работать на устаревших версиях прошивки PSP Yes = Да @@ -982,7 +982,7 @@ written = Написан на C++ для скорости и портируем [MemStick] Already contains PSP data = Уже содержит данные PSP -Cancelled - try again = Cancelled - try again +Cancelled - try again = Отменено - попробуйте еще раз Create or Choose a PSP folder = Создайте или выберите папку PSP Current = Текущая DataCanBeShared = Данные могут передаваться между обычным PPSSPP и Gold @@ -1182,9 +1182,9 @@ OpenGL Extensions = Расширения OpenGL Optimal frames per buffer = Оптимально кадров на буфер Optimal sample rate = Оптимальная частота дискретизации OS Information = Информация об ОС -Pixel resolution = Pixel resolution +Pixel resolution = Пиксельное разрешение PPSSPP build = Сборка PPSSPP -Present modes = Present modes +Present modes = Режимы представления Refresh rate = Частота обновления Release = Релизная RW/RX exclusive = Захват RW/RX From c85886c11e4dae5ac4891ddd3f0e21d7929d0169 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 1 Sep 2023 22:29:24 -0700 Subject: [PATCH 03/40] irjit: Use enum for rounding modes. --- Core/MIPS/IR/IRCompVFPU.cpp | 10 +++++----- Core/MIPS/IR/IRInst.h | 7 +++++++ Core/MIPS/IR/IRInterpreter.cpp | 20 ++++++++++---------- 3 files changed, 22 insertions(+), 15 deletions(-) diff --git a/Core/MIPS/IR/IRCompVFPU.cpp b/Core/MIPS/IR/IRCompVFPU.cpp index fe1d9be969..e42ac78d25 100644 --- a/Core/MIPS/IR/IRCompVFPU.cpp +++ b/Core/MIPS/IR/IRCompVFPU.cpp @@ -1196,20 +1196,20 @@ namespace MIPSComp { ir.Write(IROp::FCvtScaledWS, dregs[i], sregs[i], imm | (rmode << 6)); } else { for (int i = 0; i < n; i++) { - switch (rmode) { - case 0: // vf2in + switch (IRRoundMode(rmode)) { + case IRRoundMode::RINT_0: // vf2in ir.Write(IROp::FRound, dregs[i], sregs[i]); break; - case 1: // vf2iz + case IRRoundMode::CAST_1: // vf2iz ir.Write(IROp::FTrunc, dregs[i], sregs[i]); break; - case 2: // vf2iu + case IRRoundMode::CEIL_2: // vf2iu ir.Write(IROp::FCeil, dregs[i], sregs[i]); break; - case 3: // vf2id + case IRRoundMode::FLOOR_3: // vf2id ir.Write(IROp::FFloor, dregs[i], sregs[i]); break; diff --git a/Core/MIPS/IR/IRInst.h b/Core/MIPS/IR/IRInst.h index f49ac464ad..970faa34c2 100644 --- a/Core/MIPS/IR/IRInst.h +++ b/Core/MIPS/IR/IRInst.h @@ -252,6 +252,13 @@ enum class Vec4Init { Set_0001, }; +enum class IRRoundMode : uint8_t { + RINT_0 = 0, + CAST_1 = 1, + CEIL_2 = 2, + FLOOR_3 = 3, +}; + // Hm, unused inline IRComparison Invert(IRComparison comp) { switch (comp) { diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index d3535fd16e..ade6d64b62 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -966,11 +966,11 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, int count) { mips->fs[inst->dest] = my_isinf(src) && src < 0.0f ? -2147483648LL : 2147483647LL; break; } - switch (mips->fcr31 & 3) { - case 0: mips->fs[inst->dest] = (int)round_ieee_754(src); break; // RINT_0 - case 1: mips->fs[inst->dest] = (int)src; break; // CAST_1 - case 2: mips->fs[inst->dest] = (int)ceilf(src); break; // CEIL_2 - case 3: mips->fs[inst->dest] = (int)floorf(src); break; // FLOOR_3 + switch (IRRoundMode(mips->fcr31 & 3)) { + case IRRoundMode::RINT_0: mips->fs[inst->dest] = (int)round_ieee_754(src); break; + case IRRoundMode::CAST_1: mips->fs[inst->dest] = (int)src; break; + case IRRoundMode::CEIL_2: mips->fs[inst->dest] = (int)ceilf(src); break; + case IRRoundMode::FLOOR_3: mips->fs[inst->dest] = (int)floorf(src); break; } break; //cvt.w.s } @@ -994,11 +994,11 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, int count) { } else if (sv <= (double)(int)0x80000000) { mips->fs[inst->dest] = 0x80000000; } else { - switch (inst->src2 >> 6) { - case 0: mips->fs[inst->dest] = (int)round_ieee_754(sv); break; - case 1: mips->fs[inst->dest] = src >= 0 ? (int)floor(sv) : (int)ceil(sv); break; - case 2: mips->fs[inst->dest] = (int)ceil(sv); break; - case 3: mips->fs[inst->dest] = (int)floor(sv); break; + switch (IRRoundMode(inst->src2 >> 6)) { + case IRRoundMode::RINT_0: mips->fs[inst->dest] = (int)round_ieee_754(sv); break; + case IRRoundMode::CAST_1: mips->fs[inst->dest] = src >= 0 ? (int)floor(sv) : (int)ceil(sv); break; + case IRRoundMode::CEIL_2: mips->fs[inst->dest] = (int)ceil(sv); break; + case IRRoundMode::FLOOR_3: mips->fs[inst->dest] = (int)floor(sv); break; } } break; From c5d0e1d0cc9177ba627493808ab1b58067c1b1ba Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 1 Sep 2023 22:31:25 -0700 Subject: [PATCH 04/40] x86jit: Implement float to integer. --- Core/MIPS/x86/X64IRCompFPU.cpp | 118 ++++++++++++++++++++++++++++++++- Core/MIPS/x86/X64IRJit.h | 3 + Core/MIPS/x86/X64IRRegCache.h | 1 + 3 files changed, 120 insertions(+), 2 deletions(-) diff --git a/Core/MIPS/x86/X64IRCompFPU.cpp b/Core/MIPS/x86/X64IRCompFPU.cpp index 618e844b3d..15101eb209 100644 --- a/Core/MIPS/x86/X64IRCompFPU.cpp +++ b/Core/MIPS/x86/X64IRCompFPU.cpp @@ -56,6 +56,21 @@ void X64JitBackend::EmitFPUConstants() { Write32(val); } + + constants.mulTableVf2i = (const double *)GetCodePointer(); + for (uint8_t i = 0; i < 32; ++i) { + double fval = (1UL << i); + uint64_t val; + memcpy(&val, &fval, sizeof(val)); + + Write64(val); + } + + // Note: this first one is (double)(int)0x80000000, sign extended. + constants.minIntAsDouble = (const double *)GetCodePointer(); + Write64(0xC1E0000000000000ULL); + constants.maxIntAsDouble = (const double *)GetCodePointer(); + Write64(0x41DFFFFFFFC00000ULL); } void X64JitBackend::CompIR_FArith(IRInst inst) { @@ -533,8 +548,18 @@ void X64JitBackend::CompIR_FCvt(IRInst inst) { switch (inst.op) { case IROp::FCvtWS: - CompIR_Generic(inst); + { + regs_.Map(inst); + UCOMISS(regs_.FX(inst.src1), M(constants.positiveInfinity)); // rip accessible + + CVTPS2DQ(regs_.FX(inst.dest), regs_.F(inst.src1)); + // UCOMISS set ZF if EQUAL (to infinity) or UNORDERED. + FixupBranch skip = J_CC(CC_NZ); + MOVAPS(regs_.FX(inst.dest), M(constants.noSignMask)); // rip accessible + + SetJumpTarget(skip); break; + } case IROp::FCvtSW: regs_.Map(inst); @@ -542,7 +567,96 @@ void X64JitBackend::CompIR_FCvt(IRInst inst) { break; case IROp::FCvtScaledWS: - CompIR_Generic(inst); + regs_.Map(inst); + if (cpu_info.bSSE4_1) { + int scale = inst.src2 & 0x1F; + int rmode = inst.src2 >> 6; + + CVTSS2SD(regs_.FX(inst.dest), regs_.F(inst.src1)); + if (scale != 0) + MULSD(regs_.FX(inst.dest), M(&constants.mulTableVf2i[scale])); // rip accessible + + // On NAN, we want maxInt anyway, so let's let it be the second param. + MAXSD(regs_.FX(inst.dest), M(constants.minIntAsDouble)); // rip accessible + MINSD(regs_.FX(inst.dest), M(constants.maxIntAsDouble)); // rip accessible + + switch (rmode) { + case 0: + ROUNDNEARPD(regs_.FX(inst.dest), regs_.F(inst.dest)); + CVTPD2DQ(regs_.FX(inst.dest), regs_.F(inst.dest)); + break; + + case 1: + CVTTPD2DQ(regs_.FX(inst.dest), regs_.F(inst.dest)); + break; + + case 2: + ROUNDCEILPD(regs_.FX(inst.dest), regs_.F(inst.dest)); + CVTPD2DQ(regs_.FX(inst.dest), regs_.F(inst.dest)); + break; + + case 3: + ROUNDFLOORPD(regs_.FX(inst.dest), regs_.F(inst.dest)); + CVTPD2DQ(regs_.FX(inst.dest), regs_.F(inst.dest)); + break; + } + } else { + int scale = inst.src2 & 0x1F; + int rmode = inst.src2 >> 6; + + int setMXCSR = -1; + bool useTrunc = false; + switch (rmode) { + case 0: + // TODO: Could skip if hasSetRounding, but we don't have the flag. + setMXCSR = 0; + break; + case 1: + useTrunc = true; + break; + case 2: + setMXCSR = 2; + break; + case 3: + setMXCSR = 1; + break; + } + + // Except for truncate, we need to update MXCSR to our preferred rounding mode. + // TODO: Might be possible to cache this and update between instructions? + // Probably kinda expensive to switch each time... + if (setMXCSR != -1) { + STMXCSR(MDisp(CTXREG, mxcsrTempOffset)); + MOV(32, R(SCRATCH1), MDisp(CTXREG, mxcsrTempOffset)); + AND(32, R(SCRATCH1), Imm32(~(3 << 13))); + if (setMXCSR != 0) { + OR(32, R(SCRATCH1), Imm32(setMXCSR << 13)); + } + MOV(32, MDisp(CTXREG, tempOffset), R(SCRATCH1)); + LDMXCSR(MDisp(CTXREG, tempOffset)); + } + + CVTSS2SD(regs_.FX(inst.dest), regs_.F(inst.src1)); + if (scale != 0) + MULSD(regs_.FX(inst.dest), M(&constants.mulTableVf2i[scale])); + + // On NAN, we want maxInt anyway, so let's let it be the second param. + MAXSD(regs_.FX(inst.dest), M(constants.minIntAsDouble)); + MINSD(regs_.FX(inst.dest), M(constants.maxIntAsDouble)); + + if (useTrunc) { + CVTTSD2SI(SCRATCH1, regs_.F(inst.dest)); + } else { + CVTSD2SI(SCRATCH1, regs_.F(inst.dest)); + } + + MOVD_xmm(regs_.FX(inst.dest), R(SCRATCH1)); + + // Return MXCSR to its previous value. + if (setMXCSR != -1) { + LDMXCSR(MDisp(CTXREG, mxcsrTempOffset)); + } + } break; case IROp::FCvtScaledSW: diff --git a/Core/MIPS/x86/X64IRJit.h b/Core/MIPS/x86/X64IRJit.h index a30268f554..9a58f645f1 100644 --- a/Core/MIPS/x86/X64IRJit.h +++ b/Core/MIPS/x86/X64IRJit.h @@ -148,6 +148,9 @@ private: const void *negativeOnes; const void *qNAN; const float *mulTableVi2f; + const double *mulTableVf2i; + const double *minIntAsDouble; + const double *maxIntAsDouble; const Float4Constant *vec4InitValues; }; Constants constants; diff --git a/Core/MIPS/x86/X64IRRegCache.h b/Core/MIPS/x86/X64IRRegCache.h index d36463d876..953c92e759 100644 --- a/Core/MIPS/x86/X64IRRegCache.h +++ b/Core/MIPS/x86/X64IRRegCache.h @@ -42,6 +42,7 @@ static constexpr auto downcountOffset = offsetof(MIPSState, downcount) - 128; static constexpr auto tempOffset = offsetof(MIPSState, temp) - 128; static constexpr auto fcr31Offset = offsetof(MIPSState, fcr31) - 128; static constexpr auto pcOffset = offsetof(MIPSState, pc) - 128; +static constexpr auto mxcsrTempOffset = offsetof(MIPSState, mxcsrTemp) - 128; enum class X64Map : uint8_t { NONE = 0, From b370a89ef2f23a8ded9e4c20439d16b5022387f5 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 1 Sep 2023 22:33:02 -0700 Subject: [PATCH 05/40] x86jit: Reduce block link padding. Reduces bloat a good bit. --- Core/MIPS/x86/X64IRCompALU.cpp | 2 +- Core/MIPS/x86/X64IRJit.cpp | 10 ++++++---- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/Core/MIPS/x86/X64IRCompALU.cpp b/Core/MIPS/x86/X64IRCompALU.cpp index 9132ce5b05..e1621b3049 100644 --- a/Core/MIPS/x86/X64IRCompALU.cpp +++ b/Core/MIPS/x86/X64IRCompALU.cpp @@ -64,7 +64,7 @@ void X64JitBackend::CompIR_Arith(IRInst inst) { case IROp::Sub: regs_.Map(inst); - if (inst.dest == inst.src2 && inst.dest == inst.src1) { + if (inst.src1 == inst.src2) { regs_.SetGPRImm(inst.dest, 0); } else if (inst.dest == inst.src2) { NEG(32, regs_.R(inst.src2)); diff --git a/Core/MIPS/x86/X64IRJit.cpp b/Core/MIPS/x86/X64IRJit.cpp index c7db4077d7..75b11b4ceb 100644 --- a/Core/MIPS/x86/X64IRJit.cpp +++ b/Core/MIPS/x86/X64IRJit.cpp @@ -29,9 +29,10 @@ namespace MIPSComp { using namespace Gen; using namespace X64IRJitConstants; -// This should be enough for exits and invalidations. -static constexpr int MIN_BLOCK_NORMAL_LEN = 16; -static constexpr int MIN_BLOCK_EXIT_LEN = 16; +// Invalidations just need a MOV and JMP. +static constexpr int MIN_BLOCK_NORMAL_LEN = 10; +// As long as we can fit a JMP, we should be fine. +static constexpr int MIN_BLOCK_EXIT_LEN = 5; X64JitBackend::X64JitBackend(JitOptions &jitopt, IRBlockCache &blocks) : IRNativeBackend(blocks), jo(jitopt), regs_(&jo) { @@ -109,7 +110,7 @@ bool X64JitBackend::CompileBlock(IRBlock *block, int block_num, bool preload) { int len = (int)GetOffset(GetCodePointer()) - block->GetTargetOffset(); if (len < MIN_BLOCK_NORMAL_LEN) { - // We need at least 16 bytes to invalidate blocks with, but larger doesn't need to align. + // We need at least 10 bytes to invalidate blocks with. ReserveCodeSpace(MIN_BLOCK_NORMAL_LEN - len); } @@ -198,6 +199,7 @@ void X64JitBackend::OverwriteExit(int srcOffset, int len, int block_num) { XEmitter emitter(writable); emitter.JMP(GetBasePtr() + nativeBlock->checkedOffset, true); int bytesWritten = (int)(emitter.GetWritableCodePtr() - writable); + _dbg_assert_(bytesWritten <= MIN_BLOCK_EXIT_LEN); if (bytesWritten < len) emitter.ReserveCodeSpace(len - bytesWritten); From 9bac755491add5c82ab4a955ae31fbcc8456dd5d Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Fri, 1 Sep 2023 22:34:22 -0700 Subject: [PATCH 06/40] x86jit: Avoid pointerify if clobbered. For x86, it's not worth it for one. --- Core/MIPS/IR/IRRegCache.cpp | 59 ++++++++++++++++++++++------ Core/MIPS/IR/IRRegCache.h | 7 ++++ Core/MIPS/x86/X64IRCompLoadStore.cpp | 9 +++-- 3 files changed, 61 insertions(+), 14 deletions(-) diff --git a/Core/MIPS/IR/IRRegCache.cpp b/Core/MIPS/IR/IRRegCache.cpp index 8c7b6a437f..f2554bc630 100644 --- a/Core/MIPS/IR/IRRegCache.cpp +++ b/Core/MIPS/IR/IRRegCache.cpp @@ -404,6 +404,52 @@ IRNativeReg IRNativeRegCacheBase::FindFreeReg(MIPSLoc type, MIPSMap flags) const return -1; } +bool IRNativeRegCacheBase::IsGPRClobbered(IRReg gpr) const { + _dbg_assert_(IsValidGPR(gpr)); + return IsRegClobbered(MIPSLoc::REG, MIPSMap::INIT, gpr); +} + +bool IRNativeRegCacheBase::IsFPRClobbered(IRReg fpr) const { + _dbg_assert_(IsValidFPR(fpr)); + return IsRegClobbered(MIPSLoc::FREG, MIPSMap::INIT, fpr + 32); +} + +IRUsage IRNativeRegCacheBase::GetNextRegUsage(const IRSituation &info, MIPSLoc type, IRReg r) const { + if (type == MIPSLoc::REG) + return IRNextGPRUsage(r, info); + else if (type == MIPSLoc::FREG || type == MIPSLoc::VREG) + return IRNextFPRUsage(r - 32, info); + _assert_msg_(false, "Unknown spill allocation type"); + return IRUsage::UNKNOWN; +} + +bool IRNativeRegCacheBase::IsRegClobbered(MIPSLoc type, MIPSMap flags, IRReg r) const { + static const int UNUSED_LOOKAHEAD_OPS = 30; + + IRSituation info; + info.lookaheadCount = UNUSED_LOOKAHEAD_OPS; + // We look starting one ahead, unlike spilling. We want to know if it clobbers later. + info.currentIndex = irIndex_ + 1; + info.instructions = irBlock_->GetInstructions(); + info.numInstructions = irBlock_->GetNumInstructions(); + + // Make sure we're on the first one if this is multi-lane. + IRReg first = r; + if (mr[r].lane != -1) + first -= mr[r].lane; + + IRUsage usage = GetNextRegUsage(info, type, first); + if (usage == IRUsage::CLOBBERED) { + // If multiple mips regs use this native reg (i.e. vector, HI/LO), check each. + bool canClobber = true; + for (IRReg m = first + 1; mr[m].nReg == mr[first].nReg && m < IRREG_INVALID && canClobber; ++m) + canClobber = GetNextRegUsage(info, type, m) == IRUsage::CLOBBERED; + + return canClobber; + } + return false; +} + IRNativeReg IRNativeRegCacheBase::FindBestToSpill(MIPSLoc type, MIPSMap flags, bool unusedOnly, bool *clobbered) const { int allocCount = 0, base = 0; const int *allocOrder = GetAllocationOrder(type, flags, allocCount, base); @@ -416,15 +462,6 @@ IRNativeReg IRNativeRegCacheBase::FindBestToSpill(MIPSLoc type, MIPSMap flags, b info.instructions = irBlock_->GetInstructions(); info.numInstructions = irBlock_->GetNumInstructions(); - auto getUsage = [type, &info](IRReg mipsReg) { - if (type == MIPSLoc::REG) - return IRNextGPRUsage(mipsReg, info); - else if (type == MIPSLoc::FREG || type == MIPSLoc::VREG) - return IRNextFPRUsage(mipsReg - 32, info); - _assert_msg_(false, "Unknown spill allocation type"); - return IRUsage::UNKNOWN; - }; - *clobbered = false; for (int i = 0; i < allocCount; i++) { IRNativeReg nreg = IRNativeReg(allocOrder[i] - base); @@ -435,7 +472,7 @@ IRNativeReg IRNativeRegCacheBase::FindBestToSpill(MIPSLoc type, MIPSMap flags, b // As it's in alloc-order, we know it's not static so we don't need to check for that. IRReg mipsReg = nr[nreg].mipsReg; - IRUsage usage = getUsage(mipsReg); + IRUsage usage = GetNextRegUsage(info, type, mipsReg); // Awesome, a clobbered reg. Let's use it? if (usage == IRUsage::CLOBBERED) { @@ -443,7 +480,7 @@ IRNativeReg IRNativeRegCacheBase::FindBestToSpill(MIPSLoc type, MIPSMap flags, b // Note: mipsReg points to the lowest numbered IRReg. bool canClobber = true; for (IRReg m = mipsReg + 1; mr[m].nReg == nreg && m < IRREG_INVALID && canClobber; ++m) - canClobber = getUsage(m) == IRUsage::CLOBBERED; + canClobber = GetNextRegUsage(info, type, m) == IRUsage::CLOBBERED; // Okay, if all can be clobbered, we're good to go. if (canClobber) { diff --git a/Core/MIPS/IR/IRRegCache.h b/Core/MIPS/IR/IRRegCache.h index 4f14ba17f1..c85bb41848 100644 --- a/Core/MIPS/IR/IRRegCache.h +++ b/Core/MIPS/IR/IRRegCache.h @@ -22,6 +22,7 @@ #include "Common/CommonTypes.h" #include "Core/MIPS/MIPS.h" +#include "Core/MIPS/IR/IRAnalysis.h" #include "Core/MIPS/IR/IRInst.h" @@ -183,6 +184,9 @@ public: void MarkGPRDirty(IRReg gpr, bool andNormalized32 = false); void MarkGPRAsPointerDirty(IRReg gpr); + bool IsGPRClobbered(IRReg gpr) const; + bool IsFPRClobbered(IRReg gpr) const; + struct Mapping { char type = '?'; IRReg reg = IRREG_INVALID; @@ -234,6 +238,9 @@ protected: void SetSpillLockIRIndex(IRReg reg, int index); int GetMipsRegOffset(IRReg r); + bool IsRegClobbered(MIPSLoc type, MIPSMap flags, IRReg r) const; + IRUsage GetNextRegUsage(const IRSituation &info, MIPSLoc type, IRReg r) const; + bool IsValidGPR(IRReg r) const; bool IsValidGPRNoZero(IRReg r) const; bool IsValidFPR(IRReg r) const; diff --git a/Core/MIPS/x86/X64IRCompLoadStore.cpp b/Core/MIPS/x86/X64IRCompLoadStore.cpp index abf0e234f8..14c12c2b8a 100644 --- a/Core/MIPS/x86/X64IRCompLoadStore.cpp +++ b/Core/MIPS/x86/X64IRCompLoadStore.cpp @@ -39,7 +39,11 @@ using namespace X64IRJitConstants; Gen::OpArg X64JitBackend::PrepareSrc1Address(IRInst inst) { const IRMeta *m = GetIRMeta(inst.op); + + bool src1IsPointer = regs_.IsGPRMappedAsPointer(inst.src1); bool readsFromSrc1 = inst.src1 == inst.src3 && (m->flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0; + // If it's about to be clobbered, don't waste time pointerifying. Use displacement. + bool clobbersSrc1 = !readsFromSrc1 && regs_.IsGPRClobbered(inst.src1); OpArg addrArg; if (inst.src1 == MIPS_REG_ZERO) { @@ -51,7 +55,7 @@ Gen::OpArg X64JitBackend::PrepareSrc1Address(IRInst inst) { #else addrArg = M(Memory::base + inst.constant); #endif - } else if ((jo.cachePointers || regs_.IsGPRMappedAsPointer(inst.src1)) && !readsFromSrc1) { + } else if ((jo.cachePointers || src1IsPointer) && !readsFromSrc1 && (!clobbersSrc1 || src1IsPointer)) { X64Reg src1 = regs_.MapGPRAsPointer(inst.src1); addrArg = MDisp(src1, (int)inst.constant); } else { @@ -59,8 +63,7 @@ Gen::OpArg X64JitBackend::PrepareSrc1Address(IRInst inst) { #ifdef MASKED_PSP_MEMORY LEA(PTRBITS, SCRATCH1, MDisp(regs_.RX(inst.src1), (int)inst.constant)); AND(PTRBITS, R(SCRATCH1), Imm32(Memory::MEMVIEW32_MASK)); - ADD(PTRBITS, R(SCRATCH1), ImmPtr(Memory::base)); - addrArg = MatR(SCRATCH1); + addrArg = MDisp(SCRATCH1, (intptr_t)Memory::base); #else #if PPSSPP_ARCH(AMD64) addrArg = MComplex(MEMBASEREG, regs_.RX(inst.src1), SCALE_1, (int)inst.constant); From 5f84887deafddcd604d31b88a552456220de2a40 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Aug 2023 11:47:02 -0700 Subject: [PATCH 07/40] irjit: Add a pass to keep Vec4s in Vec4s. --- Core/MIPS/IR/IRFrontend.cpp | 1 + Core/MIPS/IR/IRPassSimplify.cpp | 216 ++++++++++++++++++++++++++++++++ Core/MIPS/IR/IRPassSimplify.h | 1 + 3 files changed, 218 insertions(+) diff --git a/Core/MIPS/IR/IRFrontend.cpp b/Core/MIPS/IR/IRFrontend.cpp index 1cfe9fe1f3..7cd47c3d11 100644 --- a/Core/MIPS/IR/IRFrontend.cpp +++ b/Core/MIPS/IR/IRFrontend.cpp @@ -281,6 +281,7 @@ void IRFrontend::DoJit(u32 em_address, std::vector &instructions, u32 &m &OptimizeFPMoves, &PropagateConstants, &PurgeTemps, + &ReduceVec4Flush, // &ReorderLoadStore, // &MergeLoadStore, // &ThreeOpToTwoOp, diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 2687a83ade..ade8e5b86a 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -6,6 +6,7 @@ #include "Common/Data/Convert/SmallDataConvert.h" #include "Common/Log.h" #include "Core/Config.h" +#include "Core/MIPS/MIPSVFPUUtils.h" #include "Core/MIPS/IR/IRAnalysis.h" #include "Core/MIPS/IR/IRInterpreter.h" #include "Core/MIPS/IR/IRPassSimplify.h" @@ -1874,3 +1875,218 @@ bool ApplyMemoryValidation(const IRWriter &in, IRWriter &out, const IROptions &o } return logBlocks; } + +bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { + CONDITIONAL_DISABLE; + // Only do this when using a SIMD backend. + if (!opts.preferVec4) { + DISABLE; + } + + bool isVec4[256]{}; + bool isUsed[256]{}; + bool isVec4Dirty[256]{}; + auto updateVec4 = [&](char type, IRReg r) { + bool downgraded = false; + switch (type) { + case 'F': + downgraded = isVec4[r & ~3]; + isVec4[r & ~3] = false; + isUsed[r] = true; + break; + + case 'V': + _dbg_assert_((r & 3) == 0); + isVec4[r] = true; + for (int i = 0; i < 4; ++i) + isUsed[r + i] = true; + break; + + case '2': + downgraded = isVec4[r & ~3]; + isVec4[r & ~3] = false; + for (int i = 0; i < 2; ++i) + isUsed[r + i] = true; + break; + + default: + break; + } + + return downgraded; + }; + auto updateVec4Dest = [&](char type, IRReg r, uint32_t flags) { + if ((flags & IRFLAG_SRC3) == 0) { + switch (type) { + case 'F': + isVec4Dirty[r & ~3] = false; + break; + + case 'V': + _dbg_assert_((r & 3) == 0); + isVec4Dirty[r] = true; + break; + + case '2': + isVec4Dirty[r & ~3] = false; + break; + + default: + break; + } + } + return updateVec4(type, r); + }; + + // Checks overlap from r1 to other params. + auto overlapped = [](IRReg r1, int l1, IRReg r2, int l2, IRReg r3 = IRREG_INVALID, int l3 = 0) { + if (r1 < r2 + l2 && r1 + l1 > r2) + return true; + if (r1 < r3 + l3 && r1 + l1 > r3) + return true; + return false; + }; + + bool logBlocks = false; + int inCount = (int)in.GetInstructions().size(); + for (int i = 0; i < inCount; ++i) { + IRInst inst = in.GetInstructions()[i]; + const IRMeta *m = GetIRMeta(inst.op); + + if ((m->flags & (IRFLAG_EXIT | IRFLAG_BARRIER)) != 0) { + memset(isVec4, 0, sizeof(isVec4)); + out.Write(inst); + continue; + } + + IRReg temp = IRREG_INVALID; + auto findAvailTempVec4 = [&]() { + // If it's not used yet in this block, we can use it. + // Note: even if the instruction uses it to write, that should be fine. + for (IRReg r = IRVTEMP_PFX_S; r < IRVTEMP_0 + 4; r += 4) { + if (isUsed[r]) + continue; + + bool usable = true; + for (int j = 1; j < 4; ++j) + usable = usable && !isUsed[r + j]; + + if (usable) { + temp = r; + // We don't update isUsed because our temporary doesn't need to last. + return true; + } + } + + return false; + }; + + switch (inst.op) { + case IROp::SetConstF: + if (isVec4[inst.dest & ~3] && findAvailTempVec4()) { + // Check if we're setting multiple in a row, this is a bit common. + u8 blendMask = 1 << (inst.dest & 3); + while (i + 1 < inCount) { + IRInst next = in.GetInstructions()[i + 1]; + if (next.op != IROp::SetConstF || (next.dest & ~3) != (inst.dest & ~3)) + break; + if (next.constant != inst.constant) + break; + + blendMask |= 1 << (next.dest & 3); + i++; + } + + if (inst.constant == 0) { + out.Write(IROp::Vec4Init, temp, (int)Vec4Init::AllZERO); + } else if (inst.constant == 0x3F800000) { + out.Write(IROp::Vec4Init, temp, (int)Vec4Init::AllONE); + } else if (inst.constant == 0xBF800000) { + out.Write(IROp::Vec4Init, temp, (int)Vec4Init::AllMinusONE); + } else { + out.Write(IROp::SetConstF, temp, out.AddConstant(inst.constant)); + out.Write(IROp::Vec4Shuffle, temp, temp, 0); + } + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } + break; + + case IROp::FMovFromGPR: + if (isVec4[inst.dest & ~3] && findAvailTempVec4()) { + u8 blendMask = 1 << (inst.dest & 3); + out.Write(IROp::FMovFromGPR, temp, inst.src1); + out.Write(IROp::Vec4Shuffle, temp, temp, 0); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } + break; + + case IROp::LoadFloat: + if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && findAvailTempVec4()) { + u8 blendMask = 1 << (inst.dest & 3); + out.Write(inst.op, temp, inst.src1, inst.src2, inst.constant); + out.Write(IROp::Vec4Shuffle, temp, temp, 0); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } + break; + + case IROp::FMov: + if (isVec4[inst.dest & ~3] && (inst.dest & ~3) == (inst.src1 & ~3)) { + // Oh, actually a shuffle? + uint8_t shuffle = (uint8_t)VFPU_SWIZZLE(0, 1, 2, 3); + uint8_t destShift = (inst.dest & 3) * 2; + shuffle = (shuffle & ~(3 << destShift)) | ((inst.src1 & 3) << destShift); + out.Write(IROp::Vec4Shuffle, inst.dest & ~3, inst.dest & ~3, shuffle); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } else if (isVec4[inst.dest & ~3] && isVec4[inst.src1 & ~3] && (inst.dest & 3) == (inst.src1 & 3)) { + // We can turn this directly into a blend, since it's the same lane. + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, inst.src1 & ~3, 1 << (inst.dest & 3)); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } else if (isVec4[inst.dest & ~3] && isVec4[inst.src1 & ~3] && findAvailTempVec4()) { + // For this, we'll need a temporary to move to the right lane. + uint8_t shuffle = (uint8_t)VFPU_SWIZZLE(inst.src1 & 3, inst.src1 & 3, inst.src1 & 3, inst.src1 & 3); + out.Write(IROp::Vec4Shuffle, temp, inst.src1 & ~3, shuffle); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, 1 << (inst.dest & 3)); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } + break; + + case IROp::FAdd: + case IROp::FSub: + case IROp::FMul: + case IROp::FDiv: + if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && findAvailTempVec4()) { + u8 blendMask = 1 << (inst.dest & 3); + out.Write(inst.op, temp, inst.src1, inst.src2); + out.Write(IROp::Vec4Shuffle, temp, temp, 0); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } + break; + } + + bool downgrade = false; + if (updateVec4Dest(m->types[0], inst.dest, m->flags)) + downgrade = true; + if (updateVec4(m->types[1], inst.src1)) + downgrade = true; + if (updateVec4(m->types[2], inst.src2)) + downgrade = true; + + if (downgrade) { + //WARN_LOG(JIT, "Vec4 downgrade by: %s", m->name); + } + + out.Write(inst); + } + return logBlocks; +} diff --git a/Core/MIPS/IR/IRPassSimplify.h b/Core/MIPS/IR/IRPassSimplify.h index 7fdc5d1c7d..c7c644351e 100644 --- a/Core/MIPS/IR/IRPassSimplify.h +++ b/Core/MIPS/IR/IRPassSimplify.h @@ -15,3 +15,4 @@ bool OptimizeFPMoves(const IRWriter &in, IRWriter &out, const IROptions &opts); bool ReorderLoadStore(const IRWriter &in, IRWriter &out, const IROptions &opts); bool MergeLoadStore(const IRWriter &in, IRWriter &out, const IROptions &opts); bool ApplyMemoryValidation(const IRWriter &in, IRWriter &out, const IROptions &opts); +bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts); From 96c90c19c6febb1f12f95cbdb5f5a8fa57ec8902 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 27 Aug 2023 20:48:18 -0700 Subject: [PATCH 08/40] irjit: Reduce unnecessary shuffles. If it's never used as a Vec4 again, it's often not worth it. --- Core/MIPS/IR/IRPassSimplify.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index ade8e5b86a..9284b61598 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -1981,6 +1981,20 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { return false; }; + auto usedLaterAsVec4 = [&](IRReg r) { + for (int j = i + 1; j < inCount; ++j) { + IRInst inst = in.GetInstructions()[j]; + const IRMeta *m = GetIRMeta(inst.op); + if (m->types[0] == 'V' && inst.dest == r) + return true; + if (m->types[1] == 'V' && inst.src1 == r) + return true; + if (m->types[2] == 'V' && inst.src2 == r) + return true; + } + return false; + }; + switch (inst.op) { case IROp::SetConstF: if (isVec4[inst.dest & ~3] && findAvailTempVec4()) { @@ -2063,7 +2077,7 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { case IROp::FSub: case IROp::FMul: case IROp::FDiv: - if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && findAvailTempVec4()) { + if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && usedLaterAsVec4(inst.dest & ~3) && findAvailTempVec4()) { u8 blendMask = 1 << (inst.dest & 3); out.Write(inst.op, temp, inst.src1, inst.src2); out.Write(IROp::Vec4Shuffle, temp, temp, 0); From 2ca638868c56dc088c31ee7d70f6584c398573c3 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 28 Aug 2023 20:37:40 -0700 Subject: [PATCH 09/40] irjit: Remove Vec4Scale/Vec4Dot aliasing in pass. --- Core/MIPS/IR/IRPassSimplify.cpp | 45 +++++++++++++++++++++++++-------- 1 file changed, 35 insertions(+), 10 deletions(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 9284b61598..74cf65fe18 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -1995,6 +1995,7 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { return false; }; + bool skip = false; switch (inst.op) { case IROp::SetConstF: if (isVec4[inst.dest & ~3] && findAvailTempVec4()) { @@ -2077,30 +2078,54 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { case IROp::FSub: case IROp::FMul: case IROp::FDiv: - if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && usedLaterAsVec4(inst.dest & ~3) && findAvailTempVec4()) { - u8 blendMask = 1 << (inst.dest & 3); - out.Write(inst.op, temp, inst.src1, inst.src2); - out.Write(IROp::Vec4Shuffle, temp, temp, 0); - out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); - isVec4Dirty[inst.dest & ~3] = true; - continue; + if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && usedLaterAsVec4(inst.dest & ~3)) { + if (!overlapped(inst.dest & ~3, 4, inst.src1, 1, inst.src2, 1) && findAvailTempVec4()) { + u8 blendMask = 1 << (inst.dest & 3); + out.Write(inst.op, temp, inst.src1, inst.src2); + out.Write(IROp::Vec4Shuffle, temp, temp, 0); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, blendMask); + updateVec4('F', inst.src1); + updateVec4('F', inst.src2); + isVec4Dirty[inst.dest & ~3] = true; + continue; + } } break; + + case IROp::Vec4Dot: + if (overlapped(inst.dest, 1, inst.src1, 4, inst.src2, 4) && findAvailTempVec4()) { + out.Write(inst.op, temp, inst.src1, inst.src2, inst.constant); + out.Write(IROp::FMov, inst.dest, temp); + skip = true; + } + break; + + case IROp::Vec4Scale: + if (overlapped(inst.src2, 1, inst.src1, 4, inst.dest, 4) && findAvailTempVec4()) { + out.Write(IROp::FMov, temp, inst.src2); + out.Write(inst.op, inst.dest, inst.src1, temp, inst.constant); + skip = true; + } + break; + + default: + break; } bool downgrade = false; - if (updateVec4Dest(m->types[0], inst.dest, m->flags)) - downgrade = true; if (updateVec4(m->types[1], inst.src1)) downgrade = true; if (updateVec4(m->types[2], inst.src2)) downgrade = true; + if (updateVec4Dest(m->types[0], inst.dest, m->flags)) + downgrade = true; if (downgrade) { //WARN_LOG(JIT, "Vec4 downgrade by: %s", m->name); } - out.Write(inst); + if (!skip) + out.Write(inst); } return logBlocks; } From becad5492370693c2b27aaddb11187ba8127a560 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Mon, 28 Aug 2023 21:00:54 -0700 Subject: [PATCH 10/40] x86jit: Maintain Vec4 on FMov extract. --- Core/MIPS/x86/X64IRCompFPU.cpp | 50 ++++++++++++++++++++-------------- Core/MIPS/x86/X64IRJit.h | 1 + 2 files changed, 30 insertions(+), 21 deletions(-) diff --git a/Core/MIPS/x86/X64IRCompFPU.cpp b/Core/MIPS/x86/X64IRCompFPU.cpp index 618e844b3d..ee43326832 100644 --- a/Core/MIPS/x86/X64IRCompFPU.cpp +++ b/Core/MIPS/x86/X64IRCompFPU.cpp @@ -58,6 +58,24 @@ void X64JitBackend::EmitFPUConstants() { } } +void X64JitBackend::CopyVec4ToFPRLane0(Gen::X64Reg dest, Gen::X64Reg src, int lane) { + // TODO: Move to regcache or emitter maybe? + if (lane == 0) { + if (dest != src) + MOVAPS(dest, R(src)); + } else if (lane == 1 && cpu_info.bSSE3) { + MOVSHDUP(dest, R(src)); + } else if (lane == 2) { + MOVHLPS(dest, src); + } else if (cpu_info.bAVX) { + VPERMILPS(128, dest, R(src), VFPU_SWIZZLE(lane, lane, lane, lane)); + } else { + if (dest != src) + MOVAPS(dest, R(src)); + SHUFPS(dest, R(dest), VFPU_SWIZZLE(lane, lane, lane, lane)); + } +} + void X64JitBackend::CompIR_FArith(IRInst inst) { CONDITIONAL_DISABLE; @@ -174,7 +192,15 @@ void X64JitBackend::CompIR_FAssign(IRInst inst) { switch (inst.op) { case IROp::FMov: - if (inst.dest != inst.src1) { + // Just to make sure we don't generate bad code. + if (inst.dest == inst.src1) + break; + if (regs_.IsFPRMapped(inst.src1 & 3) && regs_.GetFPRLaneCount(inst.src1 & ~3) == 4 && (inst.dest & ~3) != (inst.src1 & ~3)) { + // Okay, this is an extract. Avoid unvec4ing src1. + regs_.SpillLockFPR(inst.src1); + regs_.MapFPR(inst.dest, MIPSMap::NOINIT); + CopyVec4ToFPRLane0(regs_.FX(inst.dest), regs_.FX(inst.src1 & ~3), inst.src1 & 3); + } else { regs_.Map(inst); MOVAPS(regs_.FX(inst.dest), regs_.F(inst.src1)); } @@ -688,31 +714,13 @@ static uint32_t x64_asin(uint32_t v) { void X64JitBackend::CompIR_FSpecial(IRInst inst) { CONDITIONAL_DISABLE; - // TODO: Regcache... maybe emitter helper too? - auto laneToReg0 = [&](X64Reg dest, X64Reg src, int lane) { - if (lane == 0) { - if (dest != src) - MOVAPS(dest, R(src)); - } else if (lane == 1 && cpu_info.bSSE3) { - MOVSHDUP(dest, R(src)); - } else if (lane == 2) { - MOVHLPS(dest, src); - } else if (cpu_info.bAVX) { - VPERMILPS(128, dest, R(src), VFPU_SWIZZLE(lane, lane, lane, lane)); - } else { - if (dest != src) - MOVAPS(dest, R(src)); - SHUFPS(dest, R(dest), VFPU_SWIZZLE(lane, lane, lane, lane)); - } - }; - auto callFuncF_F = [&](const void *func) { regs_.FlushBeforeCall(); #if X64JIT_USE_XMM_CALL if (regs_.IsFPRMapped(inst.src1)) { int lane = regs_.GetFPRLane(inst.src1); - laneToReg0(XMM0, regs_.FX(inst.src1), lane); + CopyVec4ToFPRLane0(XMM0, regs_.FX(inst.src1), lane); } else { // Account for CTXREG being increased by 128 to reduce imm sizes. int offset = offsetof(MIPSState, f) + inst.src1 * 4 - 128; @@ -728,7 +736,7 @@ void X64JitBackend::CompIR_FSpecial(IRInst inst) { if (lane == 0) { MOVD_xmm(R(SCRATCH1), regs_.FX(inst.src1)); } else { - laneToReg0(XMM0, regs_.FX(inst.src1), lane); + CopyVec4ToFPRLane0(XMM0, regs_.FX(inst.src1), lane); MOVD_xmm(R(SCRATCH1), XMM0); } } else { diff --git a/Core/MIPS/x86/X64IRJit.h b/Core/MIPS/x86/X64IRJit.h index a30268f554..cb892d80d1 100644 --- a/Core/MIPS/x86/X64IRJit.h +++ b/Core/MIPS/x86/X64IRJit.h @@ -124,6 +124,7 @@ private: void EmitVecConstants(); Gen::OpArg PrepareSrc1Address(IRInst inst); + void CopyVec4ToFPRLane0(Gen::X64Reg dest, Gen::X64Reg src, int lane); JitOptions &jo; X64IRRegCache regs_; From 739e474957c3c9673083de3c012452ed3aa41008 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Tue, 29 Aug 2023 07:46:17 -0700 Subject: [PATCH 11/40] irjit: Improve dot and store vec4 interaction. --- Core/MIPS/IR/IRPassSimplify.cpp | 37 ++++++++++++++++++++++++++------- 1 file changed, 30 insertions(+), 7 deletions(-) diff --git a/Core/MIPS/IR/IRPassSimplify.cpp b/Core/MIPS/IR/IRPassSimplify.cpp index 74cf65fe18..87aa27687d 100644 --- a/Core/MIPS/IR/IRPassSimplify.cpp +++ b/Core/MIPS/IR/IRPassSimplify.cpp @@ -2040,7 +2040,7 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { break; case IROp::LoadFloat: - if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && findAvailTempVec4()) { + if (isVec4[inst.dest & ~3] && isVec4Dirty[inst.dest & ~3] && usedLaterAsVec4(inst.dest & ~3) && findAvailTempVec4()) { u8 blendMask = 1 << (inst.dest & 3); out.Write(inst.op, temp, inst.src1, inst.src2, inst.constant); out.Write(IROp::Vec4Shuffle, temp, temp, 0); @@ -2050,6 +2050,14 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { } break; + case IROp::StoreFloat: + if (isVec4[inst.src3 & ~3] && isVec4Dirty[inst.src3 & ~3] && usedLaterAsVec4(inst.src3 & ~3) && findAvailTempVec4()) { + out.Write(IROp::FMov, temp, inst.src3, 0); + out.Write(inst.op, temp, inst.src1, inst.src2, inst.constant); + continue; + } + break; + case IROp::FMov: if (isVec4[inst.dest & ~3] && (inst.dest & ~3) == (inst.src1 & ~3)) { // Oh, actually a shuffle? @@ -2059,14 +2067,15 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { out.Write(IROp::Vec4Shuffle, inst.dest & ~3, inst.dest & ~3, shuffle); isVec4Dirty[inst.dest & ~3] = true; continue; - } else if (isVec4[inst.dest & ~3] && isVec4[inst.src1 & ~3] && (inst.dest & 3) == (inst.src1 & 3)) { + } else if (isVec4[inst.dest & ~3] && (inst.dest & 3) == (inst.src1 & 3)) { // We can turn this directly into a blend, since it's the same lane. out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, inst.src1 & ~3, 1 << (inst.dest & 3)); isVec4Dirty[inst.dest & ~3] = true; continue; } else if (isVec4[inst.dest & ~3] && isVec4[inst.src1 & ~3] && findAvailTempVec4()) { // For this, we'll need a temporary to move to the right lane. - uint8_t shuffle = (uint8_t)VFPU_SWIZZLE(inst.src1 & 3, inst.src1 & 3, inst.src1 & 3, inst.src1 & 3); + int lane = inst.src1 & 3; + uint8_t shuffle = (uint8_t)VFPU_SWIZZLE(lane, lane, lane, lane); out.Write(IROp::Vec4Shuffle, temp, inst.src1 & ~3, shuffle); out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, 1 << (inst.dest & 3)); isVec4Dirty[inst.dest & ~3] = true; @@ -2095,7 +2104,15 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { case IROp::Vec4Dot: if (overlapped(inst.dest, 1, inst.src1, 4, inst.src2, 4) && findAvailTempVec4()) { out.Write(inst.op, temp, inst.src1, inst.src2, inst.constant); - out.Write(IROp::FMov, inst.dest, temp); + if (usedLaterAsVec4(inst.dest & ~3)) { + out.Write(IROp::Vec4Shuffle, temp, inst.src1 & ~3, 0); + out.Write(IROp::Vec4Blend, inst.dest & ~3, inst.dest & ~3, temp, 1 << (inst.dest & 3)); + // It's overlapped, so it'll get marked as Vec4 and used anyway. + isVec4Dirty[inst.dest & ~3] = true; + inst.dest = IRREG_INVALID; + } else { + out.Write(IROp::FMov, inst.dest, temp); + } skip = true; } break; @@ -2105,6 +2122,12 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { out.Write(IROp::FMov, temp, inst.src2); out.Write(inst.op, inst.dest, inst.src1, temp, inst.constant); skip = true; + inst.src2 = IRREG_INVALID; + } else if (isVec4[inst.src2 & 3] && usedLaterAsVec4(inst.src2 & ~3) && findAvailTempVec4()) { + out.Write(IROp::FMov, temp, inst.src2); + out.Write(inst.op, inst.dest, inst.src1, temp, inst.constant); + skip = true; + inst.src2 = IRREG_INVALID; } break; @@ -2113,11 +2136,11 @@ bool ReduceVec4Flush(const IRWriter &in, IRWriter &out, const IROptions &opts) { } bool downgrade = false; - if (updateVec4(m->types[1], inst.src1)) + if (inst.src1 != IRREG_INVALID && updateVec4(m->types[1], inst.src1)) downgrade = true; - if (updateVec4(m->types[2], inst.src2)) + if (inst.src2 != IRREG_INVALID && updateVec4(m->types[2], inst.src2)) downgrade = true; - if (updateVec4Dest(m->types[0], inst.dest, m->flags)) + if (inst.dest != IRREG_INVALID && updateVec4Dest(m->types[0], inst.dest, m->flags)) downgrade = true; if (downgrade) { From 043ee699d35fdf13383208c2a26e08e55662b8ca Mon Sep 17 00:00:00 2001 From: Felipe Date: Sat, 2 Sep 2023 10:24:03 -0300 Subject: [PATCH 12/40] Updated brazilian portuguese translation Updated the strings for the release of the version 1.16. --- assets/lang/pt_BR.ini | 35 +++++++++++++++++------------------ 1 file changed, 17 insertions(+), 18 deletions(-) diff --git a/assets/lang/pt_BR.ini b/assets/lang/pt_BR.ini index fbf4638442..a93fbee341 100644 --- a/assets/lang/pt_BR.ini +++ b/assets/lang/pt_BR.ini @@ -130,7 +130,7 @@ Deadzone radius = Raio da zona morta Disable D-Pad diagonals (4-way touch) = Desativar diagonais do D-Pad (toque de 4 direções) Disable diagonal input = Desativar entrada diagonal Double tap = Toque duplo -Enable analog stick gesture = Enable analog stick gesture +Enable analog stick gesture = Ativar gesto do direcional analógico Enable gesture control = Ativar controle dos gestos Enable standard shortcut keys = Ativar teclas padrão dos atalhos frames = frames @@ -170,7 +170,7 @@ Sensitivity = Sensibilidade Sensitivity (scale) = Sensibilidade (escala) Shape = Forma Show Touch Pause Menu Button = Mostrar o botão do menu da pausa -Sticky D-Pad (easier sweeping movements) = Sticky D-Pad (easier sweeping movements) +Sticky D-Pad (easier sweeping movements) = Direcional pegajoso (movimentos abrangentes mais fáceis) Swipe = Deslizar Swipe sensitivity = Sensibilidade do deslizar Swipe smoothing = Suavidade do deslizar @@ -310,8 +310,8 @@ Copy savestates to memstick root = Copiar os save states pra raiz do cartão de Create frame dump = Criar dump do frame Create/Open textures.ini file for current game = Criar/Abrir o arquivo textures.ini pro jogo atual Current = Atual -Debug overlay = Debug overlay -Debug stats = Debug stats +Debug overlay = Sobreposição do debug +Debug stats = Estatísticas do debug Dev Tools = Ferramentas de desenvolvimento DevMenu = Menu do DEV Disabled JIT functionality = Funcionalidade do JIT desativada @@ -326,7 +326,7 @@ FPU = FPU Framedump tests = Testes dos dumps dos frames Frame Profiler = Analista dos frames Frame timing = Tempo do frame -GPU Allocator Viewer = GPU Allocator Viewer +GPU Allocator Viewer = Visualizador do Distribuidor da GPU GPU Driver Test = Teste do driver da GPU GPU Profile = Perfil da GPU GPU log profiler = Criador do perfil do registro da GPU @@ -339,7 +339,7 @@ Logging Channels = Canais do registro Multi-threaded rendering = Renderização multi-threads Next = Próximo No block = Nenhum bloco -Off = Off +Off = Desligado Prev = Anterior Random = Aleatório Replace textures = Substituir texturas @@ -454,7 +454,6 @@ Supported = Suportado There is no data = Não há dados. Toggle All = Alternar todos Toggle List = Alternar lista -Top Center = Top center Unsupported = Não suportado Top Left = A esquerda do topo Top Right = A direita do topo @@ -615,7 +614,7 @@ Frame Skipping = Pulo dos frames Frame Skipping Type = Tipo de pulo dos frames FullScreen = Tela cheia Geometry shader culling = Abate do shader da geometria -Hack Settings = Configurações dos hacks (pode causar erros gráficos) +Hack Settings = Configurações dos hacks (pode causar erros gráficos) Hardware Tessellation = Tesselação por hardware Hardware Transform = Transformação por hardware hardware transform error - falling back to software = Erro de transformação pelo hardware, retrocedendo pro software. @@ -980,17 +979,17 @@ tools = Ferramentas grátis usadas: # Leave extra lines blank. 4 contributors per line seems to look best. translators1 = Papel, gabrielmop, Efraim Lopes, AkiraJkr translators2 = Felipe -translators3 = -translators4 = -translators5 = -translators6 = +translators3 = +translators4 = +translators5 = +translators6 = Twitter @PPSSPP_emu = Twitter @PPSSPP_emu website = Verifique o site da web: written = Escrito em C++ pela velocidade e portabilidade [MemStick] Already contains PSP data = Já contém dados do PSP -Cancelled - try again = Cancelled - try again +Cancelled - try again = Cancelado - tente de novo Create or Choose a PSP folder = Criar ou escolher uma pasta do PSP Current = Atual DataCanBeShared = Os dados podem ser compartilhados entre o PPSSPP regular/Gold @@ -1189,7 +1188,7 @@ Icon cache = Cache do ícone JIT available = JIT disponível Lang/Region = Idioma/Região Memory Page Size = Tamanho da página de memória -Native resolution = Resolução nativa +Native Resolution = Resolução nativa No GPU driver bugs detected = Não foram detectado bugs no driver da GPU OGL Extensions = Extensões do OGL OpenGL ES 2.0 Extensions = Extensões do OpenGL 2.0 ES @@ -1198,12 +1197,12 @@ OpenGL Extensions = Extensões do OpenGL Optimal frames per buffer = Melhores frames por buffer Optimal sample rate = Melhor taxa de amostragem OS Information = Informação do sistema operacional -Pixel resolution = Pixel resolution +Pixel resolution = Resolução dos pixels PPSSPP build = Build do PPSSPP -Present modes = Present modes +Present modes = Modos presentes Refresh rate = Taxa de atualização Release = Lançamento -RW/RX exclusive = RW/RX exclusivo +RW/RX exclusive = Exclusivo do RW/RX Sample rate = Taxa de amostragem Shading Language = Idioma do shader Storage = Armazenagem @@ -1212,7 +1211,7 @@ System Information = Informação do sistema System Name = Nome System Version = Versão do sistema Threads = Threads -UI resolution = Resolução da Interface do Usuário +UI Resolution = Resolução da Interface do Usuário Vendor = Vendedor Vendor (detected) = Vendedor (detectado) Version Information = Informação da versão From 980b2158ba149e6e1a90fb96ccbdc559931adf50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sat, 2 Sep 2023 15:42:47 +0200 Subject: [PATCH 13/40] Hide the "System Information / Internals" tab in release builds --- UI/DevScreens.cpp | 13 ++++++++++++- UI/DevScreens.h | 2 +- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/UI/DevScreens.cpp b/UI/DevScreens.cpp index 339b277638..4179b38052 100644 --- a/UI/DevScreens.cpp +++ b/UI/DevScreens.cpp @@ -858,7 +858,19 @@ void SystemInfoScreen::CreateTabs() { } } +#ifdef _DEBUG LinearLayout *internals = AddTab("DevSystemInfoInternals", si->T("Internals")); + CreateInternalsTab(internals); +#endif +} + +void SystemInfoScreen::CreateInternalsTab(UI::ViewGroup *internals) { + using namespace UI; + + auto di = GetI18NCategory(I18NCat::DIALOG); + auto si = GetI18NCategory(I18NCat::SYSINFO); + auto sy = GetI18NCategory(I18NCat::SYSTEM); + auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS); internals->Add(new ItemHeader(si->T("Icon cache"))); IconCacheStats iconStats = g_iconCache.GetStats(); @@ -929,7 +941,6 @@ void SystemInfoScreen::CreateTabs() { }); static const char *positions[] = { "Bottom Left", "Bottom Center", "Bottom Right", "Top Left", "Top Center", "Top Right", "Center Left", "Center Right", "None" }; - auto ac = GetI18NCategory(I18NCat::ACHIEVEMENTS); internals->Add(new ItemHeader(ac->T("Notifications"))); internals->Add(new PopupMultiChoice(&g_Config.iAchievementsLeaderboardTrackerPos, ac->T("Leaderboard tracker"), positions, 0, ARRAY_SIZE(positions), I18NCat::DIALOG, screenManager()))->SetEnabledPtr(&g_Config.bAchievementsEnable); diff --git a/UI/DevScreens.h b/UI/DevScreens.h index d000bfb594..3572061c9f 100644 --- a/UI/DevScreens.h +++ b/UI/DevScreens.h @@ -110,11 +110,11 @@ public: const char *tag() const override { return "SystemInfo"; } void CreateTabs() override; - void update() override; protected: bool ShowSearchControls() const override { return false; } + void CreateInternalsTab(UI::ViewGroup *internals); }; class AddressPromptScreen : public PopupScreen { From cef849107908c0e0e89be187a04c37eec5637dfe Mon Sep 17 00:00:00 2001 From: Dominik Date: Sat, 2 Sep 2023 20:05:58 +0200 Subject: [PATCH 14/40] Update pl_PL.ini More Polish translations and minor fixes once again. --- assets/lang/pl_PL.ini | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/assets/lang/pl_PL.ini b/assets/lang/pl_PL.ini index fc9cec0be7..c848e47dcc 100644 --- a/assets/lang/pl_PL.ini +++ b/assets/lang/pl_PL.ini @@ -1,7 +1,7 @@ [Achievements] %1: Attempt failed = %1: Próba nieudana %1: Attempt started = %1: Próba wystartowała -%d achievements, %d points = %d achievements, %d points +%d achievements, %d points = %d Osiągnięć, %d punktów Account = Konto Achievement progress = Postęp osiągnięcia Achievement unlocked = Osiągnięcie odblokowane @@ -24,11 +24,11 @@ Failed to connect to RetroAchievements. Achievements will not unlock. = Łączen Failed to identify game. Achievements will not unlock. = Identyfikacja gry nieudana. Osiągnięcia nie będą odblokowywane. How to use RetroAchievements = Jak używać RetroAchievements In Encore mode - listings may be wrong below = In Encore mode - listings may be wrong below -Leaderboard attempt started or failed = Leaderboard attempt started or failed -Leaderboard result submitted = Leaderboard result submitted -Leaderboard score submission = Leaderboard score submission -Leaderboard submission is enabled = Leaderboard submission is enabled -Leaderboard tracker = Leaderboard tracker +Leaderboard attempt started or failed = Start Tabeli wyników udany lub nieudany +Leaderboard result submitted = Rezultat tabeli wyników przesłany +Leaderboard score submission = Przesyłanie rezultatów tabeli wyników +Leaderboard submission is enabled = Przesyłanie rezultatów tabeli wyników włączone +Leaderboard tracker = Śledzenie tabeli wyników Leaderboards = Tabele wyników Links = Linki Locked achievements = Zablokowane osiągnięcia @@ -41,11 +41,11 @@ Register on www.retroachievements.org = Zarejestruj się na www.retroachievement RetroAchievements are not available for this game = Usługa RetroAchievements nie jest dostępna dla tej gry RetroAchievements website = Strona internetowa RetroAchievements Rich Presence = Rich Presence -Save state loaded without achievement data = Save state loaded without achievement data +Save state loaded without achievement data = Zapis stanu załadowany bez danych osiągnięć Save states not available in Challenge Mode = Zapisy stanu nie są dostępne w Trybie Wyzwania Sound Effects = Efekty dźwiękowe Statistics = Statystyki -Submitted %1 for %2 = Submitted %1 for %2 +Submitted %1 for %2 = Przesłano %1 dla %2 Syncing achievements data... = Synchronizacja osiągnięć... Test Mode = Tryb Testowy This feature is not available in Challenge Mode = Ta funkcja nie jest dostępna w Trybie Wyzwania @@ -106,8 +106,8 @@ Deadzone radius = Promień martwej strefy Disable D-Pad diagonals (4-way touch) = Wył. przekątne krzyżaka (pozostaw 4 kierunki) Disable diagonal input = Wyłącz wejście cyfrowe Double tap = Dwukrotne dotknięcie -Enable analog stick gesture = Enable analog stick gesture -Enable gesture control = Włącz kontrolę kestami +Enable analog stick gesture = Włącz gesty gałki analogowej +Enable gesture control = Włącz kontrolę gestami Enable standard shortcut keys = Włącz standardowe klawisze skrótów frames = klatki Gesture = Gesty @@ -138,7 +138,7 @@ OnScreen = Przyciski ekranowe Portrait = Pionowo Portrait Reversed = Odwrócone pionowo PSP Action Buttons = Klawisze akcji PSP -Rapid fire interval = Rapid fire interval +Rapid fire interval = Raw input = Zwykłe wejście Repeat mode = Tryb powtarzania Reset to defaults = Domyślne @@ -147,7 +147,7 @@ Sensitivity (scale) = Czułość (dostosuj) Sensitivity = Czułość Shape = Kształt Show Touch Pause Menu Button = Pokaż dotykowy przycisk Menu Pauzy -Sticky D-Pad (easier sweeping movements) = Lepki D-Pad (easier sweeping movements) +Sticky D-Pad (easier sweeping movements) = Lepki D-Pad (łatwiejsze ruchy rozległe) Swipe = Przesunięcie palcem Swipe sensitivity = Czułość przesunięcia Swipe smoothing = Wygładzanie przesunięcia @@ -186,7 +186,7 @@ Break = Zatrzymaj Break on Load = Zatrzymaj po załadowaniu Buy Gold = Kup wersję Gold Control Mapping... = Ustawienia przycisków... -Copy PSP memory base address = Copy PSP memory base &address +Copy PSP memory base address = Copy Skopiuj bazę i adresy pamięci PSP Debugging = &Debugowanie Deposterize = Deposteryzacja Direct3D9 = &Direct3D9 @@ -310,10 +310,10 @@ Log Dropped Frame Statistics = Loguj statystyki pominiętych klatek Log Level = Poziom dziennika zdarzeń Log View = Pokaż dziennik zdarzeń Logging Channels = Kanały dziennika zdarzeń debugera -Multi-threaded rendering = Multi-threaded rendering +Multi-threaded rendering = Renderowanie wielowątkowe Next = Następny No block = Brak bloku -Off = Off +Off = Wyłączone Prev = Poprzedni Random = Przypadkowy Replace textures = Podmiana tekstur @@ -332,7 +332,7 @@ System Information = Informacje o systemie Texture ini file created = Stworzono plik ini Tekstury Texture Replacement = Podmiana tekstur Audio Debug = Debugowanie audio -Control Debug = Control Debug +Control Debug = Debugowanie sterowania Toggle Freeze = Wł./Wył. zamrożenie Touchscreen Test = Test ekranu dotykowego Ubershaders = Ubershaders @@ -386,7 +386,7 @@ Grid = Rozmiar siatki Inactive = Nieaktywny Installing... = Instalowanie... InternalError = Występił wewnętrzny błąd aplikacji -Links = Links +Links = Linki Load = Wczytaj Load completed = Ładowanie zakończone. Loading = Ładowanie\nProszę czekać... From 77baa4e89b1dba55573c0c1761dfe72f3ad1087a Mon Sep 17 00:00:00 2001 From: fp64 <106717720+fp64@users.noreply.github.com> Date: Sat, 2 Sep 2023 18:47:37 -0400 Subject: [PATCH 15/40] Implement Ctrl-W and Ctrl-B on SDL Closes #18052. --- SDL/SDLMain.cpp | 22 ++++++++++++++++++++++ UI/GameSettingsScreen.cpp | 4 +++- 2 files changed, 25 insertions(+), 1 deletion(-) diff --git a/SDL/SDLMain.cpp b/SDL/SDLMain.cpp index 6d19a66171..03408e426e 100644 --- a/SDL/SDLMain.cpp +++ b/SDL/SDLMain.cpp @@ -862,6 +862,28 @@ static void ProcessSDLEvent(SDL_Window *window, const SDL_Event &event, InputSta g_rebootEmuThread = true; } #endif + // Convenience subset of what + // "Enable standard shortcut keys" + // does on Windows. + if(g_Config.bSystemControls) { + bool ctrl = bool(event.key.keysym.mod & KMOD_CTRL); + if (ctrl && (k == SDLK_w)) + { + if (Core_IsStepping()) + Core_EnableStepping(false); + Core_Stop(); + System_PostUIMessage("stop", ""); + // NOTE: Unlike Windows version, this + // does not need Core_WaitInactive(); + // since SDL does not have a separate + // UI thread. + } + if (ctrl && (k == SDLK_b)) + { + System_PostUIMessage("reset", ""); + Core_EnableStepping(false); + } + } break; } case SDL_KEYUP: diff --git a/UI/GameSettingsScreen.cpp b/UI/GameSettingsScreen.cpp index 7a6b3a3a93..1fe8f2b1bf 100644 --- a/UI/GameSettingsScreen.cpp +++ b/UI/GameSettingsScreen.cpp @@ -642,8 +642,10 @@ void GameSettingsScreen::CreateControlsSettings(UI::ViewGroup *controlsSettings) controlsSettings->Add(new Choice(co->T("Control Mapping")))->OnClick.Handle(this, &GameSettingsScreen::OnControlMapping); controlsSettings->Add(new Choice(co->T("Calibrate Analog Stick")))->OnClick.Handle(this, &GameSettingsScreen::OnCalibrateAnalogs); -#if defined(USING_WIN_UI) +#if defined(USING_WIN_UI) || (PPSSPP_PLATFORM(LINUX) && !PPSSPP_PLATFORM(ANDROID)) controlsSettings->Add(new CheckBox(&g_Config.bSystemControls, co->T("Enable standard shortcut keys"))); +#endif +#if defined(USING_WIN_UI) controlsSettings->Add(new CheckBox(&g_Config.bGamepadOnlyFocused, co->T("Ignore gamepads when not focused"))); #endif From 32feb82d16945264673cca9235c95d765aa831de Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 2 Sep 2023 22:55:45 -0700 Subject: [PATCH 16/40] HLE: Capture better allocation names. We know which FPL, so don't just say "FPL". --- Core/HLE/sceAtrac.cpp | 2 +- Core/HLE/sceHeap.cpp | 3 ++- Core/HLE/sceKernelHeap.cpp | 3 ++- Core/HLE/sceKernelMemory.cpp | 6 +++--- Core/HLE/sceKernelMsgPipe.cpp | 2 +- Core/HLE/sceKernelThread.cpp | 25 ++++++++++--------------- 6 files changed, 19 insertions(+), 22 deletions(-) diff --git a/Core/HLE/sceAtrac.cpp b/Core/HLE/sceAtrac.cpp index bf16281139..86017681b6 100644 --- a/Core/HLE/sceAtrac.cpp +++ b/Core/HLE/sceAtrac.cpp @@ -2375,7 +2375,7 @@ static u32 _sceAtracGetContextAddress(int atracID) { if (!atrac->context_.IsValid()) { // allocate a new context_ u32 contextsize = 256; - atrac->context_ = kernelMemory.Alloc(contextsize, false, "Atrac Context"); + atrac->context_ = kernelMemory.Alloc(contextsize, false, StringFromFormat("AtracCtx/%d", atracID).c_str()); if (atrac->context_.IsValid()) Memory::Memset(atrac->context_.ptr, 0, 256, "AtracContextClear"); diff --git a/Core/HLE/sceHeap.cpp b/Core/HLE/sceHeap.cpp index e51f6b1d83..28cc63ee43 100644 --- a/Core/HLE/sceHeap.cpp +++ b/Core/HLE/sceHeap.cpp @@ -19,6 +19,7 @@ #include "Common/Serialize/Serializer.h" #include "Common/Serialize/SerializeFuncs.h" #include "Common/Serialize/SerializeMap.h" +#include "Common/StringUtils.h" #include "Core/MemMap.h" #include "Core/Reporting.h" #include "Core/HLE/HLE.h" @@ -193,7 +194,7 @@ static int sceHeapCreateHeap(const char* name, u32 heapSize, int attr, u32 param Heap *heap = new Heap; heap->size = allocSize; heap->fromtop = (attr & PSP_HEAP_ATTR_HIGHMEM) != 0; - u32 addr = userMemory.Alloc(heap->size, heap->fromtop, "Heap"); + u32 addr = userMemory.Alloc(heap->size, heap->fromtop, StringFromFormat("Heap/%s", name).c_str()); if (addr == (u32)-1) { ERROR_LOG(HLE, "sceHeapCreateHeap(): Failed to allocate %i bytes memory", allocSize); delete heap; diff --git a/Core/HLE/sceKernelHeap.cpp b/Core/HLE/sceKernelHeap.cpp index d099fc3819..1663c81eec 100644 --- a/Core/HLE/sceKernelHeap.cpp +++ b/Core/HLE/sceKernelHeap.cpp @@ -2,6 +2,7 @@ #include "Common/Serialize/Serializer.h" #include "Common/Serialize/SerializeFuncs.h" +#include "Common/StringUtils.h" #include "Core/HLE/HLE.h" #include "Core/HLE/FunctionWrappers.h" #include "Core/HLE/sceKernel.h" @@ -52,7 +53,7 @@ static int sceKernelCreateHeap(int partitionId, int size, int flags, const char return hleLogError(SCEKERNEL, SCE_KERNEL_ERROR_ILLEGAL_ARGUMENT, "invalid partition"); // TODO: This should probably actually use flags? Name? - u32 addr = allocator->Alloc(allocSize, g_fromBottom, "SysMemForKernel-Heap"); + u32 addr = allocator->Alloc(allocSize, g_fromBottom, StringFromFormat("KernelHeap/%s", Name).c_str()); if (addr == (u32)-1) { // TODO: Validate error code. return hleLogError(SCEKERNEL, SCE_KERNEL_ERROR_NO_MEMORY, "fFailed to allocate %d bytes of memory", size); diff --git a/Core/HLE/sceKernelMemory.cpp b/Core/HLE/sceKernelMemory.cpp index d2ca493844..8c3c6fd3ae 100644 --- a/Core/HLE/sceKernelMemory.cpp +++ b/Core/HLE/sceKernelMemory.cpp @@ -678,7 +678,7 @@ int sceKernelCreateFpl(const char *name, u32 mpid, u32 attr, u32 blockSize, u32 int alignedSize = ((int)blockSize + alignment - 1) & ~(alignment - 1); u32 totalSize = alignedSize * numBlocks; bool atEnd = (attr & PSP_FPL_ATTR_HIGHMEM) != 0; - u32 address = allocator->Alloc(totalSize, atEnd, "FPL"); + u32 address = allocator->Alloc(totalSize, atEnd, StringFromFormat("FPL/%s", name).c_str()); if (address == (u32)-1) { DEBUG_LOG(SCEKERNEL, "sceKernelCreateFpl(\"%s\", partition=%i, attr=%08x, bsize=%i, nb=%i) FAILED - out of ram", name, mpid, attr, blockSize, numBlocks); @@ -1521,7 +1521,7 @@ SceUID sceKernelCreateVpl(const char *name, int partition, u32 attr, u32 vplSize // We ignore the upalign to 256 and do it ourselves by 8. u32 allocSize = vplSize; - u32 memBlockPtr = allocator->Alloc(allocSize, (attr & PSP_VPL_ATTR_HIGHMEM) != 0, "VPL"); + u32 memBlockPtr = allocator->Alloc(allocSize, (attr & PSP_VPL_ATTR_HIGHMEM) != 0, StringFromFormat("VPL/%s", name).c_str()); if (memBlockPtr == (u32)-1) return hleLogError(SCEKERNEL, SCE_KERNEL_ERROR_NO_MEMORY, "failed to allocate %i bytes of pool data", vplSize); @@ -2124,7 +2124,7 @@ SceUID sceKernelCreateTlspl(const char *name, u32 partition, u32 attr, u32 block u32 alignedSize = (blockSize + alignment - 1) & ~(alignment - 1); u32 totalSize = alignedSize * count; - u32 blockPtr = allocator->Alloc(totalSize, (attr & PSP_TLSPL_ATTR_HIGHMEM) != 0, name); + u32 blockPtr = allocator->Alloc(totalSize, (attr & PSP_TLSPL_ATTR_HIGHMEM) != 0, StringFromFormat("TLS/%s", name).c_str()); #ifdef _DEBUG allocator->ListBlocks(); #endif diff --git a/Core/HLE/sceKernelMsgPipe.cpp b/Core/HLE/sceKernelMsgPipe.cpp index 0ff34c6290..5b44e57bb4 100644 --- a/Core/HLE/sceKernelMsgPipe.cpp +++ b/Core/HLE/sceKernelMsgPipe.cpp @@ -687,7 +687,7 @@ int sceKernelCreateMsgPipe(const char *name, int partition, u32 attr, u32 size, if (size != 0) { // We ignore the upalign to 256. u32 allocSize = size; - memBlockPtr = allocator->Alloc(allocSize, (attr & SCE_KERNEL_MPA_HIGHMEM) != 0, "MsgPipe"); + memBlockPtr = allocator->Alloc(allocSize, (attr & SCE_KERNEL_MPA_HIGHMEM) != 0, StringFromFormat("MsgPipe/%s", name).c_str()); if (memBlockPtr == (u32)-1) return hleLogError(SCEKERNEL, SCE_KERNEL_ERROR_NO_MEMORY, "failed to allocate %i bytes for buffer", size); } diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index 995ead9667..40a575da74 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -401,15 +401,7 @@ public: FreeStack(); bool fromTop = (nt.attr & PSP_THREAD_ATTR_LOW_STACK) == 0; - if (nt.attr & PSP_THREAD_ATTR_KERNEL) - { - // Allocate stacks for kernel threads (idle) in kernel RAM - currentStack.start = kernelMemory.Alloc(stackSize, fromTop, (std::string("stack/") + nt.name).c_str()); - } - else - { - currentStack.start = userMemory.Alloc(stackSize, fromTop, (std::string("stack/") + nt.name).c_str()); - } + currentStack.start = StackAllocator().Alloc(stackSize, fromTop, StringFromFormat("stack/%s", nt.name).c_str()); if (currentStack.start == (u32)-1) { currentStack.start = 0; @@ -453,18 +445,14 @@ public: Memory::Memset(nt.initialStack, 0, nt.stackSize, "ThreadFreeStack"); } - if (nt.attr & PSP_THREAD_ATTR_KERNEL) { - kernelMemory.Free(currentStack.start); - } else { - userMemory.Free(currentStack.start); - } + StackAllocator().Free(currentStack.start); currentStack.start = 0; } } bool PushExtendedStack(u32 size) { - u32 stack = userMemory.Alloc(size, true, (std::string("extended/") + nt.name).c_str()); + u32 stack = userMemory.Alloc(size, true, StringFromFormat("extended/%s", nt.name).c_str()); if (stack == (u32)-1) return false; @@ -509,6 +497,13 @@ public: FreeStack(); } + BlockAllocator &StackAllocator() { + if (nt.attr & PSP_THREAD_ATTR_KERNEL) { + return kernelMemory; + } + return userMemory; + } + void setReturnValue(u32 retval); void setReturnValue(u64 retval); void resumeFromWait(); From c7304eccdb86e336e95c24601378133b4a2b5081 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 2 Sep 2023 23:05:56 -0700 Subject: [PATCH 17/40] x86jit: Avoid R15 for jitbase if near ctxreg. --- Core/MIPS/x86/X64IRAsm.cpp | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/Core/MIPS/x86/X64IRAsm.cpp b/Core/MIPS/x86/X64IRAsm.cpp index f2252b1a9a..7705905298 100644 --- a/Core/MIPS/x86/X64IRAsm.cpp +++ b/Core/MIPS/x86/X64IRAsm.cpp @@ -55,13 +55,17 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { jo.downcountInRegister = false; #if PPSSPP_ARCH(AMD64) bool jitbaseInR15 = false; + int jitbaseCtxDisp = 0; uintptr_t jitbase = (uintptr_t)GetBasePtr(); - if (jitbase > 0x7FFFFFFFULL) { + if (jitbase > 0x7FFFFFFFULL && !Accessible((const u8 *)&mipsState->f[0], GetBasePtr())) { jo.reserveR15ForAsm = true; jitbaseInR15 = true; } else { jo.downcountInRegister = true; jo.reserveR15ForAsm = true; + if (jitbase > 0x7FFFFFFFULL) { + jitbaseCtxDisp = (int)(GetBasePtr() - (const u8 *)&mipsState->f[0]); + } } #endif @@ -190,10 +194,14 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { // Debug if (enableDebug) { #if PPSSPP_ARCH(AMD64) - if (jitbaseInR15) + if (jitbaseInR15) { ABI_CallFunctionAA(reinterpret_cast(&ShowPC), R(MEMBASEREG), R(JITBASEREG)); - else + } else if (jitbaseCtxDisp != 0) { + LEA(64, SCRATCH1, MDisp(CTXREG, jitbaseCtxDisp)); + ABI_CallFunctionAA(reinterpret_cast(&ShowPC), R(MEMBASEREG), R(SCRATCH1)); + } else { ABI_CallFunctionAC(reinterpret_cast(&ShowPC), R(MEMBASEREG), (u32)jitbase); + } #else ABI_CallFunctionCC(reinterpret_cast(&ShowPC), (u32)Memory::base, (u32)GetBasePtr()); #endif @@ -227,6 +235,8 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { #elif PPSSPP_ARCH(AMD64) if (jitbaseInR15) { ADD(64, R(SCRATCH1), R(JITBASEREG)); + } else if (jitbaseCtxDisp) { + LEA(64, SCRATCH1, MComplex(CTXREG, SCRATCH1, SCALE_1, jitbaseCtxDisp)); } else { // See above, reserveR15ForAsm is used when above 0x7FFFFFFF. LEA(64, SCRATCH1, MDisp(SCRATCH1, (u32)jitbase)); From cb222f77e47906dc8c29e034a0b351734835a121 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sun, 3 Sep 2023 14:02:53 +0200 Subject: [PATCH 18/40] Bump the cpu_features submodule to latest --- ext/cpu_features | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/cpu_features b/ext/cpu_features index 75ec988188..fd4ffc1632 160000 --- a/ext/cpu_features +++ b/ext/cpu_features @@ -1 +1 @@ -Subproject commit 75ec988188f62281efe7bf1d133338751369bb4c +Subproject commit fd4ffc1632db7b4e763bd28ffa6fc9d761cf3587 From 8a2982be9673fb79cd683f59d4161daddec48e27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sun, 3 Sep 2023 14:40:11 +0200 Subject: [PATCH 19/40] Buildfix attempt --- CMakeLists.txt | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 4d6033eada..692989c998 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -272,6 +272,10 @@ if(MACOSX AND NOT IOS) endif() endif() +if(IOS) + add_definitions(-DHAVE_SYSCTLBYNAME) +endif() + include(FindThreads) if(APPLE) From 7941753105be8c7d22edf8d3e8757ef025dec259 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sun, 3 Sep 2023 15:16:18 +0200 Subject: [PATCH 20/40] Update ext/cmake/cpu_features/CMakeLists.txt with new changes --- ext/cmake/cpu_features/CMakeLists.txt | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/ext/cmake/cpu_features/CMakeLists.txt b/ext/cmake/cpu_features/CMakeLists.txt index e8bfdc34cf..fc85355dc1 100644 --- a/ext/cmake/cpu_features/CMakeLists.txt +++ b/ext/cmake/cpu_features/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.13) # option() honors normal variables. # see: https://cmake.org/cmake/help/git-stage/policy/CMP0077.html @@ -51,14 +51,15 @@ set(PROCESSOR_IS_X86 FALSE) set(PROCESSOR_IS_POWER FALSE) set(PROCESSOR_IS_S390X FALSE) set(PROCESSOR_IS_RISCV FALSE) +set(PROCESSOR_IS_LOONGARCH FALSE) if(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips") set(PROCESSOR_IS_MIPS TRUE) -elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64)") +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(^aarch64)|(^arm64)|(^ARM64)") set(PROCESSOR_IS_AARCH64 TRUE) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm") set(PROCESSOR_IS_ARM TRUE) -elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86_64)|(AMD64|amd64)|(^i.86$)") +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(x86_64)|(AMD64|amd64)|(^i.86$)") set(PROCESSOR_IS_X86 TRUE) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)") set(PROCESSOR_IS_POWER TRUE) @@ -66,6 +67,8 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(s390x)") set(PROCESSOR_IS_S390X TRUE) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^riscv") set(PROCESSOR_IS_RISCV TRUE) +elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^loongarch") + set(PROCESSOR_IS_LOONGARCH TRUE) endif() macro(add_cpu_features_headers_and_sources HDRS_LIST_NAME SRCS_LIST_NAME) @@ -79,6 +82,7 @@ macro(add_cpu_features_headers_and_sources HDRS_LIST_NAME SRCS_LIST_NAME) list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_arm.h) elseif(PROCESSOR_IS_AARCH64) list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_aarch64.h) + list(APPEND ${SRCS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/internal/windows_utils.h) elseif(PROCESSOR_IS_X86) list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_x86.h) list(APPEND ${SRCS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/internal/cpuid_x86.h) @@ -89,6 +93,8 @@ macro(add_cpu_features_headers_and_sources HDRS_LIST_NAME SRCS_LIST_NAME) list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_s390x.h) elseif(PROCESSOR_IS_RISCV) list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_riscv.h) + elseif(PROCESSOR_IS_LOONGARCH) + list(APPEND ${HDRS_LIST_NAME} ${PROJECT_SOURCE_DIR}/../../cpu_features/include/cpuinfo_loongarch.h) else() message(FATAL_ERROR "Unsupported architectures ${CMAKE_SYSTEM_PROCESSOR}") endif() From 416f4239e175c568f2de6606cde3f749a7252194 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Sun, 3 Sep 2023 15:18:25 +0200 Subject: [PATCH 21/40] Move the HAVE_SYSCTLBYNAME definition out of X86, remove the previous workaround --- CMakeLists.txt | 4 ---- ext/cmake/cpu_features/CMakeLists.txt | 6 ++---- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 692989c998..4d6033eada 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -272,10 +272,6 @@ if(MACOSX AND NOT IOS) endif() endif() -if(IOS) - add_definitions(-DHAVE_SYSCTLBYNAME) -endif() - include(FindThreads) if(APPLE) diff --git a/ext/cmake/cpu_features/CMakeLists.txt b/ext/cmake/cpu_features/CMakeLists.txt index fc85355dc1..5524191d06 100644 --- a/ext/cmake/cpu_features/CMakeLists.txt +++ b/ext/cmake/cpu_features/CMakeLists.txt @@ -154,10 +154,8 @@ endif() target_include_directories(cpu_features PUBLIC $ ) -if(PROCESSOR_IS_X86) - if(APPLE) - target_compile_definitions(cpu_features PRIVATE HAVE_SYSCTLBYNAME) - endif() +if(APPLE) + target_compile_definitions(cpu_features PRIVATE HAVE_SYSCTLBYNAME) endif() add_library(CpuFeature::cpu_features ALIAS cpu_features) From 1b756ff8c12308b01311e5b41773bea86294f678 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 11:30:04 -0700 Subject: [PATCH 22/40] arm64jit: Add initial base for IR jit. This works, but very slowly at this point. --- CMakeLists.txt | 11 + Common/Arm64Emitter.cpp | 2 +- Core/Core.vcxproj | 11 + Core/Core.vcxproj.filters | 33 ++ Core/MIPS/ARM64/Arm64IRAsm.cpp | 274 +++++++++++ Core/MIPS/ARM64/Arm64IRCompALU.cpp | 227 +++++++++ Core/MIPS/ARM64/Arm64IRCompBranch.cpp | 83 ++++ Core/MIPS/ARM64/Arm64IRCompFPU.cpp | 218 +++++++++ Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp | 174 +++++++ Core/MIPS/ARM64/Arm64IRCompSystem.cpp | 147 ++++++ Core/MIPS/ARM64/Arm64IRCompVec.cpp | 132 ++++++ Core/MIPS/ARM64/Arm64IRJit.cpp | 372 +++++++++++++++ Core/MIPS/ARM64/Arm64IRJit.h | 153 ++++++ Core/MIPS/ARM64/Arm64IRRegCache.cpp | 577 +++++++++++++++++++++++ Core/MIPS/ARM64/Arm64IRRegCache.h | 108 +++++ Core/MIPS/IR/IRFrontend.cpp | 1 - Core/MIPS/IR/IRNativeCommon.cpp | 4 + Core/MIPS/IR/IRNativeCommon.h | 4 + Core/MIPS/JitCommon/JitCommon.cpp | 3 + Core/MIPS/RiscV/RiscVJit.cpp | 5 +- Core/MIPS/RiscV/RiscVRegCache.cpp | 2 - Core/MIPS/RiscV/RiscVRegCache.h | 2 +- Core/MIPS/x86/X64IRCompALU.cpp | 1 + Core/MIPS/x86/X64IRCompSystem.cpp | 2 +- Core/MIPS/x86/X64IRJit.cpp | 2 - Core/MIPS/x86/X64IRJit.h | 6 +- Core/MIPS/x86/X64IRRegCache.cpp | 12 +- Core/MIPS/x86/X64IRRegCache.h | 4 +- UWP/CoreUWP/CoreUWP.vcxproj | 11 + UWP/CoreUWP/CoreUWP.vcxproj.filters | 33 ++ android/jni/Android.mk | 9 + libretro/Makefile.common | 9 + 32 files changed, 2610 insertions(+), 22 deletions(-) create mode 100644 Core/MIPS/ARM64/Arm64IRAsm.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompALU.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompBranch.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompFPU.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompSystem.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRCompVec.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRJit.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRJit.h create mode 100644 Core/MIPS/ARM64/Arm64IRRegCache.cpp create mode 100644 Core/MIPS/ARM64/Arm64IRRegCache.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4d6033eada..199d5f53ac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1591,6 +1591,17 @@ list(APPEND CoreExtra Core/MIPS/ARM64/Arm64RegCache.h Core/MIPS/ARM64/Arm64RegCacheFPU.cpp Core/MIPS/ARM64/Arm64RegCacheFPU.h + Core/MIPS/ARM64/Arm64IRAsm.cpp + Core/MIPS/ARM64/Arm64IRCompALU.cpp + Core/MIPS/ARM64/Arm64IRCompBranch.cpp + Core/MIPS/ARM64/Arm64IRCompFPU.cpp + Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp + Core/MIPS/ARM64/Arm64IRCompSystem.cpp + Core/MIPS/ARM64/Arm64IRCompVec.cpp + Core/MIPS/ARM64/Arm64IRJit.cpp + Core/MIPS/ARM64/Arm64IRJit.h + Core/MIPS/ARM64/Arm64IRRegCache.cpp + Core/MIPS/ARM64/Arm64IRRegCache.h GPU/Common/VertexDecoderArm64.cpp Core/Util/DisArm64.cpp ) diff --git a/Common/Arm64Emitter.cpp b/Common/Arm64Emitter.cpp index 91c658d445..2323d289e2 100644 --- a/Common/Arm64Emitter.cpp +++ b/Common/Arm64Emitter.cpp @@ -514,7 +514,7 @@ void ARM64XEmitter::EncodeTestBranchInst(u32 op, ARM64Reg Rt, u8 bits, const voi distance >>= 2; - _assert_msg_(distance >= -0x1FFF && distance < 0x1FFF, "%s: Received too large distance: %llx", __FUNCTION__, distance); + _assert_msg_(distance >= -0x2000 && distance <= 0x1FFF, "%s: Received too large distance: %llx", __FUNCTION__, distance); Rt = DecodeReg(Rt); Write32((b64Bit << 31) | (0x36 << 24) | (op << 24) | \ diff --git a/Core/Core.vcxproj b/Core/Core.vcxproj index bd3fb17ad7..cbba66cf14 100644 --- a/Core/Core.vcxproj +++ b/Core/Core.vcxproj @@ -580,6 +580,15 @@ + + + + + + + + + @@ -1175,6 +1184,8 @@ + + diff --git a/Core/Core.vcxproj.filters b/Core/Core.vcxproj.filters index 15964c072c..1de238c01f 100644 --- a/Core/Core.vcxproj.filters +++ b/Core/Core.vcxproj.filters @@ -1270,6 +1270,33 @@ MIPS\x86 + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + @@ -2037,6 +2064,12 @@ MIPS\x86 + + MIPS\ARM64 + + + MIPS\ARM64 + diff --git a/Core/MIPS/ARM64/Arm64IRAsm.cpp b/Core/MIPS/ARM64/Arm64IRAsm.cpp new file mode 100644 index 0000000000..a7c97293c8 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRAsm.cpp @@ -0,0 +1,274 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Common/Log.h" +#include "Core/CoreTiming.h" +#include "Core/MemMap.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" +#include "Core/MIPS/JitCommon/JitCommon.h" +#include "Core/MIPS/JitCommon/JitState.h" +#include "Core/System.h" + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +static const bool enableDebug = false; +static const bool enableDisasm = false; + +static void ShowPC(void *membase, void *jitbase) { + static int count = 0; + if (currentMIPS) { + u32 downcount = currentMIPS->downcount; + ERROR_LOG(JIT, "[%08x] ShowPC Downcount : %08x %d %p %p", currentMIPS->pc, downcount, count, membase, jitbase); + } else { + ERROR_LOG(JIT, "Universe corrupt?"); + } + //if (count > 2000) + // exit(0); + count++; +} + +void Arm64JitBackend::GenerateFixedCode(MIPSState *mipsState) { + BeginWrite(GetMemoryProtectPageSize()); + const u8 *start = AlignCodePage(); + + if (jo.useStaticAlloc) { + saveStaticRegisters_ = AlignCode16(); + STR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount)); + regs_.EmitSaveStaticRegisters(); + RET(); + + loadStaticRegisters_ = AlignCode16(); + regs_.EmitLoadStaticRegisters(); + LDR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount)); + RET(); + + start = saveStaticRegisters_; + } else { + saveStaticRegisters_ = nullptr; + loadStaticRegisters_ = nullptr; + } + + restoreRoundingMode_ = AlignCode16(); + { + MRS(SCRATCH2_64, FIELD_FPCR); + // We are not in flush-to-zero mode outside the JIT, so let's turn it off. + uint32_t mask = ~(4 << 22); + // Assume we're always in round-to-nearest mode beforehand. + mask &= ~(3 << 22); + ANDI2R(SCRATCH2, SCRATCH2, mask); + _MSR(FIELD_FPCR, SCRATCH2_64); + RET(); + } + + applyRoundingMode_ = AlignCode16(); + { + LDR(INDEX_UNSIGNED, SCRATCH1, CTXREG, offsetof(MIPSState, fcr31)); + ANDI2R(SCRATCH2, SCRATCH1, 3); + FixupBranch skip1 = TBZ(SCRATCH1, 24); + ADDI2R(SCRATCH2, SCRATCH2, 4); + SetJumpTarget(skip1); + + // We can skip if the rounding mode is nearest (0) and flush is not set. + // (as restoreRoundingMode cleared it out anyway) + FixupBranch skip = CBZ(SCRATCH2); + + // MIPS Rounding Mode: ARM Rounding Mode + // 0: Round nearest 0 + // 1: Round to zero 3 + // 2: Round up (ceil) 1 + // 3: Round down (floor) 2 + ANDI2R(SCRATCH1, SCRATCH2, 3); + CMPI2R(SCRATCH1, 1); + + FixupBranch skipadd = B(CC_NEQ); + ADDI2R(SCRATCH2, SCRATCH2, 2); + SetJumpTarget(skipadd); + FixupBranch skipsub = B(CC_LE); + SUBI2R(SCRATCH2, SCRATCH2, 1); + SetJumpTarget(skipsub); + + // Actually change the system FPCR register + MRS(SCRATCH1_64, FIELD_FPCR); + // Clear both flush-to-zero and rounding before re-setting them. + ANDI2R(SCRATCH1, SCRATCH1, ~((4 | 3) << 22)); + ORR(SCRATCH1, SCRATCH1, SCRATCH2, ArithOption(SCRATCH2, ST_LSL, 22)); + _MSR(FIELD_FPCR, SCRATCH1_64); + + SetJumpTarget(skip); + RET(); + } + + updateRoundingMode_ = AlignCode16(); + { + LDR(INDEX_UNSIGNED, SCRATCH1, CTXREG, offsetof(MIPSState, fcr31)); + + // Set SCRATCH2 to FZ:RM (FZ is bit 24, and RM are lowest 2 bits.) + ANDI2R(SCRATCH2, SCRATCH1, 3); + FixupBranch skip = TBZ(SCRATCH1, 24); + ADDI2R(SCRATCH2, SCRATCH2, 4); + SetJumpTarget(skip); + + // Update currentRoundingFunc_ with the right convertS0ToSCRATCH1_ func. + MOVP2R(SCRATCH1_64, convertS0ToSCRATCH1_); + LSL(SCRATCH2, SCRATCH2, 3); + LDR(SCRATCH2_64, SCRATCH1_64, SCRATCH2); + MOVP2R(SCRATCH1_64, ¤tRoundingFunc_); + STR(INDEX_UNSIGNED, SCRATCH2_64, SCRATCH1_64, 0); + RET(); + } + + hooks_.enterDispatcher = (IRNativeFuncNoArg)AlignCode16(); + + uint32_t regs_to_save = Arm64Gen::ALL_CALLEE_SAVED; + uint32_t regs_to_save_fp = Arm64Gen::ALL_CALLEE_SAVED_FP; + fp_.ABI_PushRegisters(regs_to_save, regs_to_save_fp); + + // Fixed registers, these are always kept when in Jit context. + MOVP2R(MEMBASEREG, Memory::base); + MOVP2R(CTXREG, mipsState); + // Pre-subtract this to save time later. + MOVI2R(JITBASEREG, (intptr_t)GetBasePtr() - MIPS_EMUHACK_OPCODE); + + LoadStaticRegisters(); + MovFromPC(SCRATCH1); + outerLoopPCInSCRATCH1_ = GetCodePtr(); + MovToPC(SCRATCH1); + outerLoop_ = GetCodePtr(); + SaveStaticRegisters(); // Advance can change the downcount, so must save/restore + RestoreRoundingMode(true); + QuickCallFunction(SCRATCH1_64, &CoreTiming::Advance); + ApplyRoundingMode(true); + LoadStaticRegisters(); + + dispatcherCheckCoreState_ = GetCodePtr(); + + MOVP2R(SCRATCH1_64, &coreState); + LDR(INDEX_UNSIGNED, SCRATCH1, SCRATCH1_64, 0); + FixupBranch badCoreState = CBNZ(SCRATCH1); + + // Check downcount. + TBNZ(DOWNCOUNTREG, 31, outerLoop_); + FixupBranch skipToRealDispatch = B(); + + dispatcherPCInSCRATCH1_ = GetCodePtr(); + MovToPC(SCRATCH1); + + hooks_.dispatcher = GetCodePtr(); + + FixupBranch bail = TBNZ(DOWNCOUNTREG, 31); + SetJumpTarget(skipToRealDispatch); + + dispatcherNoCheck_ = GetCodePtr(); + + // Debug + if (enableDebug) { + MOV(W0, DOWNCOUNTREG); + MOV(X1, MEMBASEREG); + MOV(X2, JITBASEREG); + QuickCallFunction(SCRATCH1_64, &ShowPC); + } + + MovFromPC(SCRATCH1); +#ifdef MASKED_PSP_MEMORY + ANDI2R(SCRATCH1, SCRATCH1, Memory::MEMVIEW32_MASK); +#endif + hooks_.dispatchFetch = GetCodePtr(); + LDR(SCRATCH1, MEMBASEREG, SCRATCH1_64); + LSR(SCRATCH2, SCRATCH1, 24); // or UBFX(SCRATCH2, SCRATCH1, 24, 8) + // We don't mask SCRATCH1 as that's already baked into JITBASEREG. + CMP(SCRATCH2, MIPS_EMUHACK_OPCODE >> 24); + FixupBranch skipJump = B(CC_NEQ); + ADD(SCRATCH1_64, JITBASEREG, SCRATCH1_64); + BR(SCRATCH1_64); + SetJumpTarget(skipJump); + + // No block found, let's jit. We don't need to save static regs, they're all callee saved. + RestoreRoundingMode(true); + QuickCallFunction(SCRATCH1_64, &MIPSComp::JitAt); + ApplyRoundingMode(true); + + // Let's just dispatch again, we'll enter the block since we know it's there. + B(dispatcherNoCheck_); + + SetJumpTarget(bail); + + MOVP2R(SCRATCH1_64, &coreState); + LDR(INDEX_UNSIGNED, SCRATCH1, SCRATCH1_64, 0); + CBZ(SCRATCH1, outerLoop_); + + const uint8_t *quitLoop = GetCodePtr(); + SetJumpTarget(badCoreState); + + SaveStaticRegisters(); + RestoreRoundingMode(true); + + fp_.ABI_PopRegisters(regs_to_save, regs_to_save_fp); + + RET(); + + hooks_.crashHandler = GetCodePtr(); + MOVP2R(SCRATCH1_64, &coreState); + MOVI2R(SCRATCH2, CORE_RUNTIME_ERROR); + STR(INDEX_UNSIGNED, SCRATCH2, SCRATCH1_64, 0); + B(quitLoop); + + // Generate some integer conversion funcs. + // MIPS order! + static const RoundingMode roundModes[8] = { ROUND_N, ROUND_Z, ROUND_P, ROUND_M, ROUND_N, ROUND_Z, ROUND_P, ROUND_M }; + for (size_t i = 0; i < ARRAY_SIZE(roundModes); ++i) { + convertS0ToSCRATCH1_[i] = AlignCode16(); + + fp_.FCMP(S0, S0); // Detect NaN + fp_.FCVTS(S0, S0, roundModes[i]); + FixupBranch skip = B(CC_VC); + MOVI2R(SCRATCH2, 0x7FFFFFFF); + fp_.FMOV(S0, SCRATCH2); + SetJumpTarget(skip); + + RET(); + } + + // Leave this at the end, add more stuff above. + if (enableDisasm) { + std::vector lines = DisassembleArm64(start, (int)(GetCodePtr() - start)); + for (auto s : lines) { + INFO_LOG(JIT, "%s", s.c_str()); + } + } + + // Let's spare the pre-generated code from unprotect-reprotect. + AlignCodePage(); + jitStartOffset_ = (int)(GetCodePtr() - start); + // Don't forget to zap the instruction cache! This must stay at the end of this function. + FlushIcache(); + EndWrite(); + + // Update our current cached rounding mode func, too. + UpdateFCR31(mipsState); +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompALU.cpp b/Core/MIPS/ARM64/Arm64IRCompALU.cpp new file mode 100644 index 0000000000..f7cefcc723 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompALU.cpp @@ -0,0 +1,227 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Common/CPUDetect.h" +#include "Core/MemMap.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for integer / arithmetic / logic related instructions. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_Arith(IRInst inst) { + CONDITIONAL_DISABLE; + + bool allowPtrMath = inst.constant <= 0x7FFFFFFF; +#ifdef MASKED_PSP_MEMORY + // Since we modify it, we can't safely. + allowPtrMath = false; +#endif + + switch (inst.op) { + case IROp::Add: + case IROp::Sub: + case IROp::AddConst: + case IROp::SubConst: + case IROp::Neg: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Assign(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Mov: + case IROp::Ext8to32: + case IROp::Ext16to32: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Bits(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::BSwap32: + case IROp::ReverseBits: + case IROp::BSwap16: + case IROp::Clz: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Compare(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Slt: + case IROp::SltConst: + case IROp::SltU: + case IROp::SltUConst: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_CondAssign(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::MovZ: + case IROp::MovNZ: + case IROp::Max: + case IROp::Min: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Div(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Div: + case IROp::DivU: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_HiLo(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::MtLo: + case IROp::MtHi: + case IROp::MfLo: + case IROp::MfHi: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Logic(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::And: + case IROp::Or: + case IROp::Xor: + case IROp::AndConst: + case IROp::OrConst: + case IROp::XorConst: + case IROp::Not: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Mult(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Mult: + case IROp::MultU: + case IROp::Madd: + case IROp::MaddU: + case IROp::Msub: + case IROp::MsubU: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Shift(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Shl: + case IROp::Shr: + case IROp::Sar: + case IROp::Ror: + case IROp::ShlImm: + case IROp::ShrImm: + case IROp::SarImm: + case IROp::RorImm: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompBranch.cpp b/Core/MIPS/ARM64/Arm64IRCompBranch.cpp new file mode 100644 index 0000000000..a14bc6c325 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompBranch.cpp @@ -0,0 +1,83 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for exits. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_Exit(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::ExitToConst: + case IROp::ExitToReg: + case IROp::ExitToPC: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_ExitIf(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::ExitToConstIfEq: + case IROp::ExitToConstIfNeq: + case IROp::ExitToConstIfGtZ: + case IROp::ExitToConstIfGeZ: + case IROp::ExitToConstIfLtZ: + case IROp::ExitToConstIfLeZ: + CompIR_Generic(inst); + break; + + case IROp::ExitToConstIfFpTrue: + case IROp::ExitToConstIfFpFalse: + // Note: not used. + DISABLE; + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompFPU.cpp b/Core/MIPS/ARM64/Arm64IRCompFPU.cpp new file mode 100644 index 0000000000..c3000b5969 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompFPU.cpp @@ -0,0 +1,218 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#ifndef offsetof +#include +#endif + +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for floating point related instructions. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_FArith(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FAdd: + case IROp::FSub: + case IROp::FMul: + case IROp::FDiv: + case IROp::FSqrt: + case IROp::FNeg: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FAssign(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FMov: + case IROp::FAbs: + case IROp::FSign: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FCompare(IRInst inst) { + CONDITIONAL_DISABLE; + + constexpr IRReg IRREG_VFPU_CC = IRREG_VFPU_CTRL_BASE + VFPU_CTRL_CC; + + switch (inst.op) { + case IROp::FCmp: + switch (inst.dest) { + case IRFpCompareMode::False: + case IRFpCompareMode::EitherUnordered: + case IRFpCompareMode::EqualOrdered: + case IRFpCompareMode::EqualUnordered: + case IRFpCompareMode::LessEqualOrdered: + case IRFpCompareMode::LessEqualUnordered: + case IRFpCompareMode::LessOrdered: + case IRFpCompareMode::LessUnordered: + CompIR_Generic(inst); + break; + } + break; + + case IROp::FCmovVfpuCC: + case IROp::FCmpVfpuBit: + case IROp::FCmpVfpuAggregate: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FCondAssign(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FMin: + case IROp::FMax: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FCvt(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FCvtWS: + case IROp::FCvtSW: + case IROp::FCvtScaledWS: + case IROp::FCvtScaledSW: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FRound(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FRound: + case IROp::FTrunc: + case IROp::FCeil: + case IROp::FFloor: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FSat(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FSat0_1: + case IROp::FSatMinus1_1: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FSpecial(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::FSin: + case IROp::FCos: + case IROp::FRSqrt: + case IROp::FRecip: + case IROp::FAsin: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_RoundingMode(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::RestoreRoundingMode: + RestoreRoundingMode(); + break; + + case IROp::ApplyRoundingMode: + ApplyRoundingMode(); + break; + + case IROp::UpdateRoundingMode: + UpdateRoundingMode(); + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp b/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp new file mode 100644 index 0000000000..29167b7dd8 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp @@ -0,0 +1,174 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Core/MemMap.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for load/store instructions. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_CondStore(IRInst inst) { + CONDITIONAL_DISABLE; + if (inst.op != IROp::Store32Conditional) + INVALIDOP; + + CompIR_Generic(inst); +} + +void Arm64JitBackend::CompIR_FLoad(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::LoadFloat: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_FStore(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::StoreFloat: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Load(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Load8: + case IROp::Load8Ext: + case IROp::Load16: + case IROp::Load16Ext: + case IROp::Load32: + case IROp::Load32Linked: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_LoadShift(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Load32Left: + case IROp::Load32Right: + // Should not happen if the pass to split is active. + DISABLE; + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Store(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Store8: + case IROp::Store16: + case IROp::Store32: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_StoreShift(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Store32Left: + case IROp::Store32Right: + // Should not happen if the pass to split is active. + DISABLE; + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecLoad(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::LoadVec4: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecStore(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::StoreVec4: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompSystem.cpp b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp new file mode 100644 index 0000000000..be4400f465 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp @@ -0,0 +1,147 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Common/Profiler/Profiler.h" +#include "Core/Core.h" +#include "Core/HLE/HLE.h" +#include "Core/HLE/ReplaceTables.h" +#include "Core/MemMap.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for basic PC/downcount accounting, syscalls, debug funcs, etc. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_Basic(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Downcount: + case IROp::SetConst: + case IROp::SetConstF: + case IROp::SetPC: + case IROp::SetPCConst: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Breakpoint(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Breakpoint: + case IROp::MemoryCheck: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_System(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Syscall: + case IROp::CallReplacement: + case IROp::Break: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_Transfer(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::SetCtrlVFPU: + case IROp::SetCtrlVFPUReg: + case IROp::SetCtrlVFPUFReg: + case IROp::FpCondFromReg: + case IROp::FpCondToReg: + case IROp::FpCtrlFromReg: + case IROp::FpCtrlToReg: + case IROp::VfpuCtrlToReg: + case IROp::FMovFromGPR: + case IROp::FMovToGPR: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_ValidateAddress(IRInst inst) { + CONDITIONAL_DISABLE; + + bool isWrite = inst.src2 & 1; + int alignment = 0; + switch (inst.op) { + case IROp::ValidateAddress8: + alignment = 1; + break; + + case IROp::ValidateAddress16: + alignment = 2; + break; + + case IROp::ValidateAddress32: + alignment = 4; + break; + + case IROp::ValidateAddress128: + alignment = 16; + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRCompVec.cpp b/Core/MIPS/ARM64/Arm64IRCompVec.cpp new file mode 100644 index 0000000000..e4fe133e3d --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRCompVec.cpp @@ -0,0 +1,132 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include +#include "Common/CPUDetect.h" +#include "Core/MemMap.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +// This file contains compilation for vector instructions. +// +// All functions should have CONDITIONAL_DISABLE, so we can narrow things down to a file quickly. +// Currently known non working ones should have DISABLE. No flags because that's in IR already. + +// #define CONDITIONAL_DISABLE { CompIR_Generic(inst); return; } +#define CONDITIONAL_DISABLE {} +#define DISABLE { CompIR_Generic(inst); return; } +#define INVALIDOP { _assert_msg_(false, "Invalid IR inst %d", (int)inst.op); CompIR_Generic(inst); return; } + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +void Arm64JitBackend::CompIR_VecArith(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Vec4Add: + case IROp::Vec4Sub: + case IROp::Vec4Mul: + case IROp::Vec4Div: + case IROp::Vec4Scale: + case IROp::Vec4Neg: + case IROp::Vec4Abs: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecAssign(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Vec4Init: + case IROp::Vec4Shuffle: + case IROp::Vec4Blend: + case IROp::Vec4Mov: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecClamp(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Vec4ClampToZero: + case IROp::Vec2ClampToZero: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecHoriz(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Vec4Dot: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +void Arm64JitBackend::CompIR_VecPack(IRInst inst) { + CONDITIONAL_DISABLE; + + switch (inst.op) { + case IROp::Vec2Unpack16To31: + case IROp::Vec4Pack32To8: + case IROp::Vec2Pack31To16: + case IROp::Vec4Unpack8To32: + case IROp::Vec2Unpack16To32: + case IROp::Vec4DuplicateUpperBitsAndShift1: + case IROp::Vec4Pack31To8: + case IROp::Vec2Pack32To16: + CompIR_Generic(inst); + break; + + default: + INVALIDOP; + break; + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRJit.cpp b/Core/MIPS/ARM64/Arm64IRJit.cpp new file mode 100644 index 0000000000..d315afef17 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRJit.cpp @@ -0,0 +1,372 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include +#include "Core/MemMap.h" +#include "Core/MIPS/MIPSTables.h" +#include "Core/MIPS/ARM64/Arm64IRJit.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +namespace MIPSComp { + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +// Invalidations just need at most two MOVs and B. +static constexpr int MIN_BLOCK_NORMAL_LEN = 12; +// As long as we can fit a B, we should be fine. +static constexpr int MIN_BLOCK_EXIT_LEN = 4; + +Arm64JitBackend::Arm64JitBackend(JitOptions &jitopt, IRBlockCache &blocks) + : IRNativeBackend(blocks), jo(jitopt), regs_(&jo), fp_(this) { + // Automatically disable incompatible options. + if (((intptr_t)Memory::base & 0x00000000FFFFFFFFUL) != 0) { + jo.enablePointerify = false; + } +#ifdef MASKED_PSP_MEMORY + jo.enablePointerify = false; +#endif + + // Since we store the offset, this is as big as it can be. + AllocCodeSpace(1024 * 1024 * 16); + + regs_.Init(this, &fp_); +} + +Arm64JitBackend::~Arm64JitBackend() {} + +void Arm64JitBackend::UpdateFCR31(MIPSState *mipsState) { + currentRoundingFunc_ = convertS0ToSCRATCH1_[mipsState->fcr31 & 3]; +} + +static void NoBlockExits() { + _assert_msg_(false, "Never exited block, invalid IR?"); +} + +bool Arm64JitBackend::CompileBlock(IRBlock *block, int block_num, bool preload) { + if (GetSpaceLeft() < 0x800) + return false; + + BeginWrite(std::min(GetSpaceLeft(), (size_t)block->GetNumInstructions() * 32)); + + u32 startPC = block->GetOriginalStart(); + bool wroteCheckedOffset = false; + if (jo.enableBlocklink && !jo.useBackJump) { + SetBlockCheckedOffset(block_num, (int)GetOffset(GetCodePointer())); + wroteCheckedOffset = true; + + // Check the sign bit to check if negative. + FixupBranch normalEntry = TBZ(DOWNCOUNTREG, 31); + MOVI2R(SCRATCH1, startPC); + B(outerLoopPCInSCRATCH1_); + SetJumpTarget(normalEntry); + } + + // Don't worry, the codespace isn't large enough to overflow offsets. + const u8 *blockStart = GetCodePointer(); + block->SetTargetOffset((int)GetOffset(blockStart)); + compilingBlockNum_ = block_num; + + regs_.Start(block); + + std::map addresses; + for (int i = 0; i < block->GetNumInstructions(); ++i) { + const IRInst &inst = block->GetInstructions()[i]; + regs_.SetIRIndex(i); + // TODO: This might be a little wasteful when compiling if we're not debugging jit... + addresses[GetCodePtr()] = i; + + CompileIRInst(inst); + + if (jo.Disabled(JitDisable::REGALLOC_GPR) || jo.Disabled(JitDisable::REGALLOC_FPR)) + regs_.FlushAll(jo.Disabled(JitDisable::REGALLOC_GPR), jo.Disabled(JitDisable::REGALLOC_FPR)); + + // Safety check, in case we get a bunch of really large jit ops without a lot of branching. + if (GetSpaceLeft() < 0x800) { + compilingBlockNum_ = -1; + return false; + } + } + + // We should've written an exit above. If we didn't, bad things will happen. + // Only check if debug stats are enabled - needlessly wastes jit space. + if (DebugStatsEnabled()) { + QuickCallFunction(SCRATCH2_64, &NoBlockExits); + B(hooks_.crashHandler); + } + + int len = (int)GetOffset(GetCodePointer()) - block->GetTargetOffset(); + if (len < MIN_BLOCK_NORMAL_LEN) { + // We need at least 10 bytes to invalidate blocks with. + ReserveCodeSpace(MIN_BLOCK_NORMAL_LEN - len); + } + + if (!wroteCheckedOffset) { + // Always record this, even if block link disabled - it's used for size calc. + SetBlockCheckedOffset(block_num, (int)GetOffset(GetCodePointer())); + } + + if (jo.enableBlocklink && jo.useBackJump) { + // Small blocks are common, check if it's < 32KB long. + ptrdiff_t distance = blockStart - GetCodePointer(); + if (distance >= -0x8000 && distance < 0x8000) { + TBZ(DOWNCOUNTREG, 31, blockStart); + } else { + FixupBranch toDispatch = TBNZ(DOWNCOUNTREG, 31); + B(blockStart); + SetJumpTarget(toDispatch); + } + + MOVI2R(SCRATCH1, startPC); + B(outerLoopPCInSCRATCH1_); + } + + if (logBlocks_ > 0) { + --logBlocks_; + + INFO_LOG(JIT, "=============== ARM64 (%08x, %d bytes) ===============", startPC, len); + for (const u8 *p = blockStart; p < GetCodePointer(); ) { + auto it = addresses.find(p); + if (it != addresses.end()) { + const IRInst &inst = block->GetInstructions()[it->second]; + + char temp[512]; + DisassembleIR(temp, sizeof(temp), inst); + INFO_LOG(JIT, "IR: #%d %s", it->second, temp); + } + + auto next = std::next(it); + const u8 *nextp = next == addresses.end() ? GetCodePointer() : next->first; + + auto lines = DisassembleArm64(p, (int)(nextp - p)); + for (const auto &line : lines) + INFO_LOG(JIT, " A: %s", line.c_str()); + p = nextp; + } + } + + EndWrite(); + FlushIcache(); + compilingBlockNum_ = -1; + + return true; +} + +void Arm64JitBackend::WriteConstExit(uint32_t pc) { + int block_num = blocks_.GetBlockNumberFromStartAddress(pc); + const IRNativeBlock *nativeBlock = GetNativeBlock(block_num); + + int exitStart = (int)GetOffset(GetCodePointer()); + if (block_num >= 0 && jo.enableBlocklink && nativeBlock && nativeBlock->checkedOffset != 0) { + B(GetBasePtr() + nativeBlock->checkedOffset); + } else { + MOVI2R(SCRATCH1, pc); + B(dispatcherPCInSCRATCH1_); + } + + if (jo.enableBlocklink) { + // In case of compression or early link, make sure it's large enough. + int len = (int)GetOffset(GetCodePointer()) - exitStart; + if (len < MIN_BLOCK_EXIT_LEN) { + ReserveCodeSpace(MIN_BLOCK_EXIT_LEN - len); + len = MIN_BLOCK_EXIT_LEN; + } + + AddLinkableExit(compilingBlockNum_, pc, exitStart, len); + } +} + +void Arm64JitBackend::OverwriteExit(int srcOffset, int len, int block_num) { + _dbg_assert_(len >= MIN_BLOCK_EXIT_LEN); + + const IRNativeBlock *nativeBlock = GetNativeBlock(block_num); + if (nativeBlock) { + u8 *writable = GetWritablePtrFromCodePtr(GetBasePtr()) + srcOffset; + if (PlatformIsWXExclusive()) { + ProtectMemoryPages(writable, len, MEM_PROT_READ | MEM_PROT_WRITE); + } + + ARM64XEmitter emitter(GetBasePtr() + srcOffset, writable); + emitter.B(GetBasePtr() + nativeBlock->checkedOffset); + int bytesWritten = (int)(emitter.GetWritableCodePtr() - writable); + _dbg_assert_(bytesWritten <= MIN_BLOCK_EXIT_LEN); + if (bytesWritten < len) + emitter.ReserveCodeSpace(len - bytesWritten); + emitter.FlushIcache(); + + if (PlatformIsWXExclusive()) { + ProtectMemoryPages(writable, 16, MEM_PROT_READ | MEM_PROT_EXEC); + } + } +} + +void Arm64JitBackend::CompIR_Generic(IRInst inst) { + // If we got here, we're going the slow way. + uint64_t value; + memcpy(&value, &inst, sizeof(inst)); + + FlushAll(); + SaveStaticRegisters(); + MOVI2R(X0, value); + QuickCallFunction(SCRATCH2_64, &DoIRInst); + LoadStaticRegisters(); + + // We only need to check the return value if it's a potential exit. + if ((GetIRMeta(inst.op)->flags & IRFLAG_EXIT) != 0) { + MOV(SCRATCH1, X0); + + ptrdiff_t distance = dispatcherPCInSCRATCH1_ - GetCodePointer(); + if (distance >= -0x100000 && distance < 0x100000) { + // Convenient, we can do a simple branch if within 1MB. + CBNZ(W0, dispatcherPCInSCRATCH1_); + } else { + // That's a shame, we need a long branch. + FixupBranch keepOnKeepingOn = CBZ(W0); + B(dispatcherPCInSCRATCH1_); + SetJumpTarget(keepOnKeepingOn); + } + } +} + +void Arm64JitBackend::CompIR_Interpret(IRInst inst) { + MIPSOpcode op(inst.constant); + + // IR protects us against this being a branching instruction (well, hopefully.) + FlushAll(); + SaveStaticRegisters(); + if (DebugStatsEnabled()) { + MOVP2R(X0, MIPSGetName(op)); + QuickCallFunction(SCRATCH2_64, &NotifyMIPSInterpret); + } + MOVI2R(X0, inst.constant); + QuickCallFunction(SCRATCH2_64, MIPSGetInterpretFunc(op)); + LoadStaticRegisters(); +} + +void Arm64JitBackend::FlushAll() { + regs_.FlushAll(); +} + +bool Arm64JitBackend::DescribeCodePtr(const u8 *ptr, std::string &name) const { + // Used in disassembly viewer and profiling tools. + // Don't use spaces; profilers get confused or truncate them. + if (ptr == dispatcherPCInSCRATCH1_) { + name = "dispatcherPCInSCRATCH1"; + } else if (ptr == outerLoopPCInSCRATCH1_) { + name = "outerLoopPCInSCRATCH1"; + } else if (ptr == dispatcherNoCheck_) { + name = "dispatcherNoCheck"; + } else if (ptr == saveStaticRegisters_) { + name = "saveStaticRegisters"; + } else if (ptr == loadStaticRegisters_) { + name = "loadStaticRegisters"; + } else if (ptr == restoreRoundingMode_) { + name = "restoreRoundingMode"; + } else if (ptr == applyRoundingMode_) { + name = "applyRoundingMode"; + } else if (ptr == updateRoundingMode_) { + name = "updateRoundingMode"; + } else if (ptr == currentRoundingFunc_) { + name = "currentRoundingFunc"; + } else if (ptr >= convertS0ToSCRATCH1_[0] && ptr <= convertS0ToSCRATCH1_[7]) { + name = "convertS0ToSCRATCH1"; + } else if (ptr >= GetBasePtr() && ptr < GetBasePtr() + jitStartOffset_) { + name = "fixedCode"; + } else { + return IRNativeBackend::DescribeCodePtr(ptr, name); + } + return true; +} + +void Arm64JitBackend::ClearAllBlocks() { + ClearCodeSpace(jitStartOffset_); + FlushIcacheSection(region + jitStartOffset_, region + region_size - jitStartOffset_); + EraseAllLinks(-1); +} + +void Arm64JitBackend::InvalidateBlock(IRBlock *block, int block_num) { + int offset = block->GetTargetOffset(); + u8 *writable = GetWritablePtrFromCodePtr(GetBasePtr()) + offset; + + // Overwrite the block with a jump to compile it again. + u32 pc = block->GetOriginalStart(); + if (pc != 0) { + // Hopefully we always have at least 16 bytes, which should be all we need. + if (PlatformIsWXExclusive()) { + ProtectMemoryPages(writable, MIN_BLOCK_NORMAL_LEN, MEM_PROT_READ | MEM_PROT_WRITE); + } + + ARM64XEmitter emitter(GetBasePtr() + offset, writable); + emitter.MOVI2R(SCRATCH1, pc); + emitter.B(dispatcherPCInSCRATCH1_); + int bytesWritten = (int)(emitter.GetWritableCodePtr() - writable); + if (bytesWritten < MIN_BLOCK_NORMAL_LEN) + emitter.ReserveCodeSpace(MIN_BLOCK_NORMAL_LEN - bytesWritten); + emitter.FlushIcache(); + + if (PlatformIsWXExclusive()) { + ProtectMemoryPages(writable, MIN_BLOCK_NORMAL_LEN, MEM_PROT_READ | MEM_PROT_EXEC); + } + } + + EraseAllLinks(block_num); +} + +void Arm64JitBackend::RestoreRoundingMode(bool force) { + QuickCallFunction(SCRATCH2_64, restoreRoundingMode_); +} + +void Arm64JitBackend::ApplyRoundingMode(bool force) { + QuickCallFunction(SCRATCH2_64, applyRoundingMode_); +} + +void Arm64JitBackend::UpdateRoundingMode(bool force) { + QuickCallFunction(SCRATCH2_64, updateRoundingMode_); +} + +void Arm64JitBackend::MovFromPC(ARM64Reg r) { + LDR(INDEX_UNSIGNED, r, CTXREG, offsetof(MIPSState, pc)); +} + +void Arm64JitBackend::MovToPC(ARM64Reg r) { + STR(INDEX_UNSIGNED, r, CTXREG, offsetof(MIPSState, pc)); +} + +void Arm64JitBackend::SaveStaticRegisters() { + if (jo.useStaticAlloc) { + QuickCallFunction(SCRATCH2_64, saveStaticRegisters_); + } else { + // Inline the single operation + STR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount)); + } +} + +void Arm64JitBackend::LoadStaticRegisters() { + if (jo.useStaticAlloc) { + QuickCallFunction(SCRATCH2_64, loadStaticRegisters_); + } else { + LDR(INDEX_UNSIGNED, DOWNCOUNTREG, CTXREG, offsetof(MIPSState, downcount)); + } +} + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRJit.h b/Core/MIPS/ARM64/Arm64IRJit.h new file mode 100644 index 0000000000..fa8bfd89f2 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRJit.h @@ -0,0 +1,153 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include +#include +#include "Common/Arm64Emitter.h" +#include "Core/MIPS/IR/IRJit.h" +#include "Core/MIPS/IR/IRNativeCommon.h" +#include "Core/MIPS/JitCommon/JitState.h" +#include "Core/MIPS/JitCommon/JitCommon.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" + +namespace MIPSComp { + +class Arm64JitBackend : public Arm64Gen::ARM64CodeBlock, public IRNativeBackend { +public: + Arm64JitBackend(JitOptions &jo, IRBlockCache &blocks); + ~Arm64JitBackend(); + + bool DescribeCodePtr(const u8 *ptr, std::string &name) const override; + + void GenerateFixedCode(MIPSState *mipsState) override; + bool CompileBlock(IRBlock *block, int block_num, bool preload) override; + void ClearAllBlocks() override; + void InvalidateBlock(IRBlock *block, int block_num) override; + + void UpdateFCR31(MIPSState *mipsState) override; + +protected: + const CodeBlockCommon &CodeBlock() const override { + return *this; + } + +private: + void RestoreRoundingMode(bool force = false); + void ApplyRoundingMode(bool force = false); + void UpdateRoundingMode(bool force = false); + void MovFromPC(Arm64Gen::ARM64Reg r); + void MovToPC(Arm64Gen::ARM64Reg r); + + void SaveStaticRegisters(); + void LoadStaticRegisters(); + + // Note: destroys SCRATCH1. + void FlushAll(); + + void WriteConstExit(uint32_t pc); + void OverwriteExit(int srcOffset, int len, int block_num) override; + + void CompIR_Arith(IRInst inst) override; + void CompIR_Assign(IRInst inst) override; + void CompIR_Basic(IRInst inst) override; + void CompIR_Bits(IRInst inst) override; + void CompIR_Breakpoint(IRInst inst) override; + void CompIR_Compare(IRInst inst) override; + void CompIR_CondAssign(IRInst inst) override; + void CompIR_CondStore(IRInst inst) override; + void CompIR_Div(IRInst inst) override; + void CompIR_Exit(IRInst inst) override; + void CompIR_ExitIf(IRInst inst) override; + void CompIR_FArith(IRInst inst) override; + void CompIR_FAssign(IRInst inst) override; + void CompIR_FCompare(IRInst inst) override; + void CompIR_FCondAssign(IRInst inst) override; + void CompIR_FCvt(IRInst inst) override; + void CompIR_FLoad(IRInst inst) override; + void CompIR_FRound(IRInst inst) override; + void CompIR_FSat(IRInst inst) override; + void CompIR_FSpecial(IRInst inst) override; + void CompIR_FStore(IRInst inst) override; + void CompIR_Generic(IRInst inst) override; + void CompIR_HiLo(IRInst inst) override; + void CompIR_Interpret(IRInst inst) override; + void CompIR_Load(IRInst inst) override; + void CompIR_LoadShift(IRInst inst) override; + void CompIR_Logic(IRInst inst) override; + void CompIR_Mult(IRInst inst) override; + void CompIR_RoundingMode(IRInst inst) override; + void CompIR_Shift(IRInst inst) override; + void CompIR_Store(IRInst inst) override; + void CompIR_StoreShift(IRInst inst) override; + void CompIR_System(IRInst inst) override; + void CompIR_Transfer(IRInst inst) override; + void CompIR_VecArith(IRInst inst) override; + void CompIR_VecAssign(IRInst inst) override; + void CompIR_VecClamp(IRInst inst) override; + void CompIR_VecHoriz(IRInst inst) override; + void CompIR_VecLoad(IRInst inst) override; + void CompIR_VecPack(IRInst inst) override; + void CompIR_VecStore(IRInst inst) override; + void CompIR_ValidateAddress(IRInst inst) override; + + JitOptions &jo; + Arm64IRRegCache regs_; + Arm64Gen::ARM64FloatEmitter fp_; + + const u8 *outerLoop_ = nullptr; + const u8 *outerLoopPCInSCRATCH1_ = nullptr; + const u8 *dispatcherCheckCoreState_ = nullptr; + const u8 *dispatcherPCInSCRATCH1_ = nullptr; + const u8 *dispatcherNoCheck_ = nullptr; + const u8 *restoreRoundingMode_ = nullptr; + const u8 *applyRoundingMode_ = nullptr; + const u8 *updateRoundingMode_ = nullptr; + + const u8 *saveStaticRegisters_ = nullptr; + const u8 *loadStaticRegisters_ = nullptr; + + // Indexed by FPCR FZ:RN bits for convenience. Uses SCRATCH2. + const u8 *convertS0ToSCRATCH1_[8]; + + // Note: mutable state used at runtime. + const u8 *currentRoundingFunc_ = nullptr; + + int jitStartOffset_ = 0; + int compilingBlockNum_ = -1; + int logBlocks_ = 0; +}; + +class Arm64IRJit : public IRNativeJit { +public: + Arm64IRJit(MIPSState *mipsState) + : IRNativeJit(mipsState), arm64Backend_(jo, blocks_) { + Init(arm64Backend_); + } + +private: + Arm64JitBackend arm64Backend_; +}; + +} // namespace MIPSComp + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRRegCache.cpp b/Core/MIPS/ARM64/Arm64IRRegCache.cpp new file mode 100644 index 0000000000..f65e418d53 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRRegCache.cpp @@ -0,0 +1,577 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#ifndef offsetof +#include +#endif + +#include "Common/CPUDetect.h" +#include "Common/LogReporting.h" +#include "Core/MemMap.h" +#include "Core/MIPS/IR/IRInst.h" +#include "Core/MIPS/IR/IRAnalysis.h" +#include "Core/MIPS/ARM64/Arm64IRRegCache.h" +#include "Core/MIPS/JitCommon/JitState.h" + +using namespace Arm64Gen; +using namespace Arm64IRJitConstants; + +Arm64IRRegCache::Arm64IRRegCache(MIPSComp::JitOptions *jo) + : IRNativeRegCacheBase(jo) { + // The S/D/Q regs overlap, so we just use one slot. The numbers don't match ARM64Reg. + config_.totalNativeRegs = NUM_X_REGS + NUM_X_FREGS; + config_.mapFPUSIMD = true; + // XMM regs are used for both FPU and Vec, so we don't need VREGs. + config_.mapUseVRegs = false; +} + +void Arm64IRRegCache::Init(ARM64XEmitter *emitter, ARM64FloatEmitter *fp) { + emit_ = emitter; + fp_ = fp; +} + +const int *Arm64IRRegCache::GetAllocationOrder(MIPSLoc type, MIPSMap flags, int &count, int &base) const { + if (type == MIPSLoc::REG) { + // See register alloc remarks in Arm64Asm.cpp. + base = W0; + + // W19-W23 are most suitable for static allocation. Those that are chosen for static allocation + // should be omitted here and added in GetStaticAllocations. + static const int allocationOrder[] = { + W19, W20, W21, W22, W23, W24, W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15, + }; + static const int allocationOrderStaticAlloc[] = { + W0, W1, W2, W3, W4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15, + }; + + if (jo_->useStaticAlloc) { + count = ARRAY_SIZE(allocationOrderStaticAlloc); + return allocationOrderStaticAlloc; + } + count = ARRAY_SIZE(allocationOrder); + return allocationOrder; + } else if (type == MIPSLoc::FREG) { + base = S0 - NUM_X_REGS; + + // We don't really need four temps, probably. + // We start with S8 for call flushes. + static const int allocationOrder[] = { + // Reserve four full 128-bit temp registers, should be plenty. + S8, S9, S10, S11, // Partially callee-save (bottom 64 bits) + S12, S13, S14, S15, // Partially callee-save (bottom 64 bits) + S16, S17, S18, S19, + S20, S21, S22, S23, + S24, S25, S26, S27, + S28, S29, S30, S31, + S4, S5, S6, S7, + }; + + count = ARRAY_SIZE(allocationOrder); + return allocationOrder; + } else { + _assert_msg_(false, "Allocation order not yet implemented"); + count = 0; + return nullptr; + } +} + +const Arm64IRRegCache::StaticAllocation *Arm64IRRegCache::GetStaticAllocations(int &count) const { + static const StaticAllocation allocs[] = { + { MIPS_REG_SP, W19, MIPSLoc::REG, true }, + { MIPS_REG_V0, W20, MIPSLoc::REG }, + { MIPS_REG_V1, W21, MIPSLoc::REG }, + { MIPS_REG_A0, W22, MIPSLoc::REG }, + { MIPS_REG_A1, W23, MIPSLoc::REG }, + { MIPS_REG_RA, W24, MIPSLoc::REG }, + }; + + if (jo_->useStaticAlloc) { + count = ARRAY_SIZE(allocs); + return allocs; + } + return IRNativeRegCacheBase::GetStaticAllocations(count); +} + +void Arm64IRRegCache::EmitLoadStaticRegisters() { + int count = 0; + const StaticAllocation *allocs = GetStaticAllocations(count); + for (int i = 0; i < count; ++i) { + int offset = GetMipsRegOffset(allocs[i].mr); + if (i + 1 < count && allocs[i].mr == allocs[i + 1].mr - 1) { + _assert_(!allocs[i].pointerified && !allocs[i + 1].pointerified); + emit_->LDP(INDEX_SIGNED, FromNativeReg(allocs[i].nr), FromNativeReg(allocs[i + 1].nr), CTXREG, offset); + ++i; + } else { + emit_->LDR(INDEX_UNSIGNED, FromNativeReg(allocs[i].nr), CTXREG, offset); + if (allocs[i].pointerified && jo_->enablePointerify) { + ARM64Reg r64 = FromNativeReg64(allocs[i].nr); + uint32_t membaseHigh = (uint32_t)((uint64_t)Memory::base >> 32); + emit_->MOVK(r64, membaseHigh & 0xFFFF, SHIFT_32); + if (membaseHigh & 0xFFFF0000) + emit_->MOVK(r64, membaseHigh >> 16, SHIFT_48); + } + } + } +} + +void Arm64IRRegCache::EmitSaveStaticRegisters() { + int count = 0; + const StaticAllocation *allocs = GetStaticAllocations(count); + // This only needs to run once (by Asm) so checks don't need to be fast. + for (int i = 0; i < count; ++i) { + int offset = GetMipsRegOffset(allocs[i].mr); + if (i + 1 < count && allocs[i].mr == allocs[i + 1].mr - 1) { + emit_->STP(INDEX_SIGNED, FromNativeReg(allocs[i].nr), FromNativeReg(allocs[i + 1].nr), CTXREG, offset); + ++i; + } else { + emit_->STR(INDEX_UNSIGNED, FromNativeReg(allocs[i].nr), CTXREG, offset); + } + } +} + +void Arm64IRRegCache::FlushBeforeCall() { + // These registers are not preserved by function calls. + auto isGPRSaved = [&](IRNativeReg nreg) { + ARM64Reg ar = FromNativeReg(nreg); + return ar >= W19 && ar <= W29; + }; + auto isFPRSaved = [&](IRNativeReg nreg) { + ARM64Reg ar = FromNativeReg(nreg); + return ar >= S8 && ar <= S15; + }; + + // Go through by IR index first, to use STP where we can. + for (int i = 1; i < TOTAL_MAPPABLE_IRREGS - 1; ++i) { + if (mr[i].nReg == -1 || mr[i + 1].nReg == -1 || mr[i].isStatic || mr[i + 1].isStatic) + continue; + // Ignore multilane regs. + if (mr[i].lane != -1 || mr[i + 1].lane != -1) + continue; + if (!nr[mr[i].nReg].isDirty || !nr[mr[i + 1].nReg].isDirty) + continue; + + int offset = GetMipsRegOffset(i); + + // Okay, it's a maybe. Are we flushing both as GPRs? + if (!isGPRSaved(mr[i].nReg) && !isGPRSaved(mr[i + 1].nReg) && offset <= 252) { + // If either is mapped as a pointer, fix it. + if (mr[i].loc == MIPSLoc::REG_AS_PTR) + AdjustNativeRegAsPtr(mr[i].nReg, false); + if (mr[i + 1].loc == MIPSLoc::REG_AS_PTR) + AdjustNativeRegAsPtr(mr[i + 1].nReg, false); + + // That means we should use STP. + emit_->STP(INDEX_SIGNED, FromNativeReg(mr[i].nReg), FromNativeReg(mr[i + 1].nReg), CTXREG, offset); + + DiscardNativeReg(mr[i].nReg); + DiscardNativeReg(mr[i + 1].nReg); + + ++i; + continue; + } + + // Perhaps as FPRs? Note: these must be single lane at this point. + // TODO: Could use STP on quads etc. too, i.e. i & i + 4. + if (!isFPRSaved(mr[i].nReg) && !isFPRSaved(mr[i + 1].nReg) && offset <= 252) { + fp_->STP(32, INDEX_SIGNED, FromNativeReg(mr[i].nReg), FromNativeReg(mr[i + 1].nReg), CTXREG, offset); + + DiscardNativeReg(mr[i].nReg); + DiscardNativeReg(mr[i + 1].nReg); + + ++i; + continue; + } + } + + // Alright, now go through any that didn't get flushed with STP. + for (int i = 0; i < 19; ++i) { + FlushNativeReg(GPRToNativeReg(ARM64Reg(W0 + i))); + } + FlushNativeReg(GPRToNativeReg(W30)); + + for (int i = 0; i < 8; ++i) { + FlushNativeReg(VFPToNativeReg(ARM64Reg(S0 + i))); + } + for (int i = 8; i < 16; ++i) { + // These are preserved but only the low 64 bits. + IRNativeReg nreg = VFPToNativeReg(ARM64Reg(S0 + i)); + if (nr[nreg].mipsReg != IRREG_INVALID && GetFPRLaneCount(nr[nreg].mipsReg - 32) > 2) + FlushNativeReg(nreg); + } + for (int i = 16; i < 32; ++i) { + FlushNativeReg(VFPToNativeReg(ARM64Reg(S0 + i))); + } +} + +ARM64Reg Arm64IRRegCache::TryMapTempImm(IRReg r) { + _dbg_assert_(IsValidGPR(r)); + + // If already mapped, no need for a temporary. + if (IsGPRMapped(r)) { + return R(r); + } + + if (mr[r].loc == MIPSLoc::IMM) { + // Can we just use zero? + if (mr[r].imm == 0) + return WZR; + + // Try our luck - check for an exact match in another xreg. + for (int i = 1; i < TOTAL_MAPPABLE_IRREGS; ++i) { + if (mr[i].loc == MIPSLoc::REG_IMM && mr[i].imm == mr[r].imm) { + // Awesome, let's just use this reg. + return FromNativeReg(mr[i].nReg); + } + } + } + + return INVALID_REG; +} + +ARM64Reg Arm64IRRegCache::GetAndLockTempGPR() { + IRNativeReg reg = AllocateReg(MIPSLoc::REG, MIPSMap::INIT); + if (reg != -1) { + nr[reg].tempLockIRIndex = irIndex_; + } + return FromNativeReg(reg); +} + +ARM64Reg Arm64IRRegCache::GetAndLockTempFPR() { + IRNativeReg reg = AllocateReg(MIPSLoc::FREG, MIPSMap::INIT); + if (reg != -1) { + nr[reg].tempLockIRIndex = irIndex_; + } + return FromNativeReg(reg); +} + +ARM64Reg Arm64IRRegCache::MapWithFPRTemp(const IRInst &inst) { + return FromNativeReg(MapWithTemp(inst, MIPSLoc::FREG)); +} + +ARM64Reg Arm64IRRegCache::MapGPR(IRReg mipsReg, MIPSMap mapFlags) { + _dbg_assert_(IsValidGPR(mipsReg)); + + // Okay, not mapped, so we need to allocate an arm64 register. + IRNativeReg nreg = MapNativeReg(MIPSLoc::REG, mipsReg, 1, mapFlags); + return FromNativeReg(nreg); +} + +ARM64Reg Arm64IRRegCache::MapGPR2(IRReg mipsReg, MIPSMap mapFlags) { + _dbg_assert_(IsValidGPR(mipsReg) && IsValidGPR(mipsReg + 1)); + + // Okay, not mapped, so we need to allocate an arm64 register. + IRNativeReg nreg = MapNativeReg(MIPSLoc::REG, mipsReg, 2, mapFlags); + return FromNativeReg64(nreg); +} + +ARM64Reg Arm64IRRegCache::MapGPRAsPointer(IRReg reg) { + return FromNativeReg64(MapNativeRegAsPointer(reg)); +} + +ARM64Reg Arm64IRRegCache::MapFPR(IRReg mipsReg, MIPSMap mapFlags) { + _dbg_assert_(IsValidFPR(mipsReg)); + _dbg_assert_(mr[mipsReg + 32].loc == MIPSLoc::MEM || mr[mipsReg + 32].loc == MIPSLoc::FREG); + + IRNativeReg nreg = MapNativeReg(MIPSLoc::FREG, mipsReg + 32, 1, mapFlags); + if (nreg != -1) + return FromNativeReg(nreg); + return INVALID_REG; +} + +ARM64Reg Arm64IRRegCache::MapVec4(IRReg first, MIPSMap mapFlags) { + _dbg_assert_(IsValidFPR(first)); + _dbg_assert_((first & 3) == 0); + _dbg_assert_(mr[first + 32].loc == MIPSLoc::MEM || mr[first + 32].loc == MIPSLoc::FREG); + + IRNativeReg nreg = MapNativeReg(MIPSLoc::FREG, first + 32, 4, mapFlags); + if (nreg != -1) + return EncodeRegToQuad(FromNativeReg(nreg)); + return INVALID_REG; +} + +void Arm64IRRegCache::AdjustNativeRegAsPtr(IRNativeReg nreg, bool state) { + _assert_(nreg >= 0 && nreg < (IRNativeReg)WZR); + ARM64Reg r = FromNativeReg64(nreg); + if (state) { + if (!jo_->enablePointerify) { +#if defined(MASKED_PSP_MEMORY) + // This destroys the value... + _dbg_assert_(!nr[nreg].isDirty); + emit_->ANDI2R(r, r, Memory::MEMVIEW32_MASK); +#endif + emit_->ADD(r, r, MEMBASEREG); + } else { + uint32_t membaseHigh = (uint32_t)((uint64_t)Memory::base >> 32); + emit_->MOVK(r, membaseHigh & 0xFFFF, SHIFT_32); + if (membaseHigh & 0xFFFF0000) + emit_->MOVK(r, membaseHigh >> 16, SHIFT_48); + } + } else { + if (!jo_->enablePointerify) { +#if defined(MASKED_PSP_MEMORY) + _dbg_assert_(!nr[nreg].isDirty); +#endif + emit_->SUB(r, r, MEMBASEREG); + } else { + // Nothing to do, just ignore the high 32 bits. + } + } +} + +bool Arm64IRRegCache::IsNativeRegCompatible(IRNativeReg nreg, MIPSLoc type, MIPSMap flags) { + // No special flags, skip the check for a little speed. + return true; +} + +void Arm64IRRegCache::LoadNativeReg(IRNativeReg nreg, IRReg first, int lanes) { + ARM64Reg r = FromNativeReg(nreg); + _dbg_assert_(first != MIPS_REG_ZERO); + if (nreg < NUM_X_REGS) { + _assert_(lanes == 1 || (lanes == 2 && first == IRREG_LO)); + if (lanes == 1) + emit_->LDR(INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 2) + emit_->LDR(INDEX_UNSIGNED, EncodeRegTo64(r), CTXREG, GetMipsRegOffset(first)); + else + _assert_(false); + } else { + _dbg_assert_(nreg < NUM_X_REGS + NUM_X_FREGS); + _assert_msg_(mr[first].loc == MIPSLoc::FREG, "Cannot load this type: %d", (int)mr[first].loc); + if (lanes == 1) + fp_->LDR(32, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 2) + fp_->LDR(64, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 4) + fp_->LDR(128, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else + _assert_(false); + } +} + +void Arm64IRRegCache::StoreNativeReg(IRNativeReg nreg, IRReg first, int lanes) { + ARM64Reg r = FromNativeReg(nreg); + _dbg_assert_(first != MIPS_REG_ZERO); + if (nreg < NUM_X_REGS) { + _assert_(lanes == 1 || (lanes == 2 && first == IRREG_LO)); + _assert_(mr[first].loc == MIPSLoc::REG || mr[first].loc == MIPSLoc::REG_IMM); + if (lanes == 1) + emit_->STR(INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 2) + emit_->STR(INDEX_UNSIGNED, EncodeRegTo64(r), CTXREG, GetMipsRegOffset(first)); + else + _assert_(false); + } else { + _dbg_assert_(nreg < NUM_X_REGS + NUM_X_FREGS); + _assert_msg_(mr[first].loc == MIPSLoc::FREG, "Cannot store this type: %d", (int)mr[first].loc); + if (lanes == 1) + fp_->STR(32, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 2) + fp_->STR(64, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else if (lanes == 4) + fp_->STR(128, INDEX_UNSIGNED, r, CTXREG, GetMipsRegOffset(first)); + else + _assert_(false); + } +} + +void Arm64IRRegCache::SetNativeRegValue(IRNativeReg nreg, uint32_t imm) { + ARM64Reg r = FromNativeReg(nreg); + _dbg_assert_(nreg >= 0 && nreg < (IRNativeReg)WZR); + // On ARM64, MOVZ/MOVK is really fast. + emit_->MOVI2R(r, imm); +} + +void Arm64IRRegCache::StoreRegValue(IRReg mreg, uint32_t imm) { + _assert_(IsValidGPRNoZero(mreg)); + // Try to optimize using a different reg. + ARM64Reg storeReg = INVALID_REG; + if (imm == 0) + storeReg = WZR; + + // Could we get lucky? Check for an exact match in another xreg. + for (int i = 1; i < TOTAL_MAPPABLE_IRREGS; ++i) { + if (mr[i].loc == MIPSLoc::REG_IMM && mr[i].imm == imm) { + // Awesome, let's just store this reg. + storeReg = (ARM64Reg)mr[i].nReg; + break; + } + } + + if (storeReg == INVALID_REG) { + emit_->MOVI2R(SCRATCH1, imm); + storeReg = SCRATCH1; + } + emit_->STR(INDEX_UNSIGNED, storeReg, CTXREG, GetMipsRegOffset(mreg)); +} + +void Arm64IRRegCache::FlushAll(bool gprs, bool fprs) { + // Note: make sure not to change the registers when flushing: + // Branching code may expect the armreg to retain its value. + + // Try to flush in pairs when possible. + for (int i = 1; i < TOTAL_MAPPABLE_IRREGS - 1; ++i) { + if (mr[i].loc == MIPSLoc::MEM || mr[i].loc == MIPSLoc::MEM || mr[i].isStatic || mr[i + 1].isStatic) + continue; + // Ignore multilane regs. Could handle with more smartness... + if (mr[i].lane != -1 || mr[i + 1].lane != -1) + continue; + if (mr[i].nReg != -1 && !nr[mr[i].nReg].isDirty) + continue; + if (mr[i + 1].nReg != -1 && !nr[mr[i + 1].nReg].isDirty) + continue; + if (mr[i].loc == MIPSLoc::MEM || mr[i + 1].loc == MIPSLoc::MEM) + continue; + + int offset = GetMipsRegOffset(i); + + // If both are imms, let's materialize a single reg and store. + if (mr[i].loc == MIPSLoc::IMM && mr[i + 1].loc == MIPSLoc::IMM) { + if ((i & 1) == 0) { + uint64_t fullImm = ((uint64_t) mr[i + 1].imm << 32) | mr[i].imm; + emit_->MOVI2R(SCRATCH1_64, fullImm); + emit_->STR(INDEX_UNSIGNED, SCRATCH1_64, CTXREG, offset); + DiscardReg(i); + DiscardReg(i + 1); + ++i; + } + continue; + } + + // Okay, two dirty regs in a row, in need of flushing. Both GPRs? + if (IsValidGPR(i) && IsValidGPR(i + 1) && offset <= 252) { + auto setupForFlush = [&](ARM64Reg &ar, IRReg r) { + if (mr[r].loc == MIPSLoc::IMM) { + ar = TryMapTempImm(r); + if (ar == INVALID_REG) { + // Both cannot be imms, so this is safe. + ar = SCRATCH1; + emit_->MOVI2R(ar, mr[r].imm); + } + } else if (mr[r].loc == MIPSLoc::REG_AS_PTR) { + AdjustNativeRegAsPtr(r, false); + ar = FromNativeReg(mr[r].nReg); + } else { + _dbg_assert_(mr[r].loc == MIPSLoc::REG || mr[r].loc == MIPSLoc::REG_IMM); + ar = FromNativeReg(mr[r].nReg); + } + }; + + ARM64Reg armRegs[2]{ INVALID_REG, INVALID_REG }; + setupForFlush(armRegs[0], i); + setupForFlush(armRegs[1], i + 1); + + emit_->STP(INDEX_SIGNED, armRegs[0], armRegs[1], CTXREG, offset); + DiscardReg(i); + DiscardReg(i + 1); + ++i; + continue; + } + + // Perhaps as FPRs? Note: these must be single lane at this point. + // TODO: Could use STP on quads etc. too, i.e. i & i + 4. + if (i >= 32 && IsValidFPR(i - 32) && IsValidFPR(i + 1 - 32) && offset <= 252) { + _dbg_assert_(mr[i].loc == MIPSLoc::FREG && mr[i + 1].loc == MIPSLoc::FREG); + fp_->STP(32, INDEX_SIGNED, FromNativeReg(mr[i].nReg), FromNativeReg(mr[i + 1].nReg), CTXREG, offset); + + DiscardNativeReg(mr[i].nReg); + DiscardNativeReg(mr[i + 1].nReg); + + ++i; + continue; + } + } + + // Flush all the rest that weren't done via STP. + IRNativeRegCacheBase::FlushAll(gprs, fprs); +} + +ARM64Reg Arm64IRRegCache::R(IRReg mipsReg) { + _dbg_assert_(IsValidGPR(mipsReg)); + _dbg_assert_(mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM); + if (mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM) { + return FromNativeReg(mr[mipsReg].nReg); + } else { + ERROR_LOG_REPORT(JIT, "Reg %i not in arm64 reg", mipsReg); + return INVALID_REG; // BAAAD + } +} + +ARM64Reg Arm64IRRegCache::RPtr(IRReg mipsReg) { + _dbg_assert_(IsValidGPR(mipsReg)); + _dbg_assert_(mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM || mr[mipsReg].loc == MIPSLoc::REG_AS_PTR); + if (mr[mipsReg].loc == MIPSLoc::REG_AS_PTR) { + return FromNativeReg64(mr[mipsReg].nReg); + } else if (mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM) { + int r = mr[mipsReg].nReg; + _dbg_assert_(nr[r].pointerified); + if (nr[r].pointerified) { + return FromNativeReg64(mr[mipsReg].nReg); + } else { + ERROR_LOG(JIT, "Tried to use a non-pointer register as a pointer"); + return INVALID_REG; + } + } else { + ERROR_LOG_REPORT(JIT, "Reg %i not in arm64 reg", mipsReg); + return INVALID_REG; // BAAAD + } +} + +ARM64Reg Arm64IRRegCache::F(IRReg mipsReg) { + _dbg_assert_(IsValidFPR(mipsReg)); + _dbg_assert_(mr[mipsReg + 32].loc == MIPSLoc::FREG); + if (mr[mipsReg + 32].loc == MIPSLoc::FREG) { + return FromNativeReg(mr[mipsReg + 32].nReg); + } else { + ERROR_LOG_REPORT(JIT, "Reg %i not in arm64 reg", mipsReg); + return INVALID_REG; // BAAAD + } +} + +ARM64Reg Arm64IRRegCache::FD(IRReg mipsReg) { + return EncodeRegToDouble(F(mipsReg)); +} + +ARM64Reg Arm64IRRegCache::FQ(IRReg mipsReg) { + return EncodeRegToQuad(F(mipsReg)); +} + +IRNativeReg Arm64IRRegCache::GPRToNativeReg(ARM64Reg r) { + _dbg_assert_msg_(r >= 0 && r < 0x40, "Not a GPR?"); + return (IRNativeReg)DecodeReg(r); +} + +IRNativeReg Arm64IRRegCache::VFPToNativeReg(ARM64Reg r) { + _dbg_assert_msg_(r >= 0x40 && r < 0xE0, "Not VFP?"); + return (IRNativeReg)(NUM_X_REGS + (int)DecodeReg(r)); +} + +ARM64Reg Arm64IRRegCache::FromNativeReg(IRNativeReg r) { + if (r >= NUM_X_REGS) + return EncodeRegToSingle((Arm64Gen::ARM64Reg)r); + return (Arm64Gen::ARM64Reg)r; +} + +ARM64Reg Arm64IRRegCache::FromNativeReg64(IRNativeReg r) { + _dbg_assert_msg_(r >= 0 && r < NUM_X_REGS, "Not a GPR?"); + return EncodeRegTo64((Arm64Gen::ARM64Reg)r); +} + +#endif diff --git a/Core/MIPS/ARM64/Arm64IRRegCache.h b/Core/MIPS/ARM64/Arm64IRRegCache.h new file mode 100644 index 0000000000..89e570d643 --- /dev/null +++ b/Core/MIPS/ARM64/Arm64IRRegCache.h @@ -0,0 +1,108 @@ +// Copyright (c) 2023- PPSSPP Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +#include "ppsspp_config.h" +// In other words, PPSSPP_ARCH(ARM64) || DISASM_ALL. +#if PPSSPP_ARCH(ARM64) || (PPSSPP_PLATFORM(WINDOWS) && !defined(__LIBRETRO__)) + +#include "Common/Arm64Emitter.h" +#include "Core/MIPS/MIPS.h" +#include "Core/MIPS/IR/IRJit.h" +#include "Core/MIPS/IR/IRRegCache.h" + +namespace Arm64IRJitConstants { + +const Arm64Gen::ARM64Reg DOWNCOUNTREG = Arm64Gen::W25; +// Note: this is actually offset from the base. +const Arm64Gen::ARM64Reg JITBASEREG = Arm64Gen::X26; +const Arm64Gen::ARM64Reg CTXREG = Arm64Gen::X27; +const Arm64Gen::ARM64Reg MEMBASEREG = Arm64Gen::X28; +const Arm64Gen::ARM64Reg SCRATCH1_64 = Arm64Gen::X16; +const Arm64Gen::ARM64Reg SCRATCH2_64 = Arm64Gen::X17; +const Arm64Gen::ARM64Reg SCRATCH1 = Arm64Gen::W16; +const Arm64Gen::ARM64Reg SCRATCH2 = Arm64Gen::W17; +// TODO: How many do we actually need? +const Arm64Gen::ARM64Reg SCRATCHF1 = Arm64Gen::S0; +const Arm64Gen::ARM64Reg SCRATCHF2 = Arm64Gen::S1; +const Arm64Gen::ARM64Reg SCRATCHF3 = Arm64Gen::S2; +const Arm64Gen::ARM64Reg SCRATCHF4 = Arm64Gen::S3; + +} // namespace X64IRJitConstants + +class Arm64IRRegCache : public IRNativeRegCacheBase { +public: + Arm64IRRegCache(MIPSComp::JitOptions *jo); + + void Init(Arm64Gen::ARM64XEmitter *emitter, Arm64Gen::ARM64FloatEmitter *fp); + + // May fail and return INVALID_REG if it needs flushing. + Arm64Gen::ARM64Reg TryMapTempImm(IRReg reg); + + // Returns an arm64 register containing the requested MIPS register. + Arm64Gen::ARM64Reg MapGPR(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); + Arm64Gen::ARM64Reg MapGPR2(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); + Arm64Gen::ARM64Reg MapGPRAsPointer(IRReg reg); + Arm64Gen::ARM64Reg MapFPR(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); + Arm64Gen::ARM64Reg MapVec4(IRReg first, MIPSMap mapFlags = MIPSMap::INIT); + + Arm64Gen::ARM64Reg MapWithFPRTemp(const IRInst &inst); + + void FlushBeforeCall(); + void FlushAll(bool gprs = true, bool fprs = true) override; + + Arm64Gen::ARM64Reg GetAndLockTempGPR(); + Arm64Gen::ARM64Reg GetAndLockTempFPR(); + + Arm64Gen::ARM64Reg R(IRReg preg); // Returns a cached register, while checking that it's NOT mapped as a pointer + Arm64Gen::ARM64Reg RPtr(IRReg preg); // Returns a cached register, if it has been mapped as a pointer + Arm64Gen::ARM64Reg F(IRReg preg); + Arm64Gen::ARM64Reg FD(IRReg preg); + Arm64Gen::ARM64Reg FQ(IRReg preg); + + // These are called once on startup to generate functions, that you should then call. + void EmitLoadStaticRegisters(); + void EmitSaveStaticRegisters(); + +protected: + const StaticAllocation *GetStaticAllocations(int &count) const override; + const int *GetAllocationOrder(MIPSLoc type, MIPSMap flags, int &count, int &base) const override; + void AdjustNativeRegAsPtr(IRNativeReg nreg, bool state) override; + + bool IsNativeRegCompatible(IRNativeReg nreg, MIPSLoc type, MIPSMap flags) override; + void LoadNativeReg(IRNativeReg nreg, IRReg first, int lanes) override; + void StoreNativeReg(IRNativeReg nreg, IRReg first, int lanes) override; + void SetNativeRegValue(IRNativeReg nreg, uint32_t imm) override; + void StoreRegValue(IRReg mreg, uint32_t imm) override; + +private: + IRNativeReg GPRToNativeReg(Arm64Gen::ARM64Reg r); + IRNativeReg VFPToNativeReg(Arm64Gen::ARM64Reg r); + Arm64Gen::ARM64Reg FromNativeReg(IRNativeReg r); + Arm64Gen::ARM64Reg FromNativeReg64(IRNativeReg r); + + Arm64Gen::ARM64XEmitter *emit_ = nullptr; + Arm64Gen::ARM64FloatEmitter *fp_ = nullptr; + + enum { + NUM_X_REGS = 32, + NUM_X_FREGS = 32, + }; +}; + +#endif diff --git a/Core/MIPS/IR/IRFrontend.cpp b/Core/MIPS/IR/IRFrontend.cpp index 7cd47c3d11..272c4fdb5f 100644 --- a/Core/MIPS/IR/IRFrontend.cpp +++ b/Core/MIPS/IR/IRFrontend.cpp @@ -34,7 +34,6 @@ namespace MIPSComp { IRFrontend::IRFrontend(bool startDefaultPrefix) { js.startDefaultPrefix = startDefaultPrefix; js.hasSetRounding = false; - // js.currentRoundingFunc = convertS0ToSCRATCH1[0]; // The debugger sets this so that "go" on a breakpoint will actually... go. // But if they reset, we can end up hitting it by mistake, since it's based on PC and ticks. diff --git a/Core/MIPS/IR/IRNativeCommon.cpp b/Core/MIPS/IR/IRNativeCommon.cpp index f9a8e00bca..6ce1e0f0d6 100644 --- a/Core/MIPS/IR/IRNativeCommon.cpp +++ b/Core/MIPS/IR/IRNativeCommon.cpp @@ -490,6 +490,10 @@ const u8 *IRNativeJit::GetCrashHandler() const { return backend_->GetNativeHooks().crashHandler; } +void IRNativeJit::UpdateFCR31() { + backend_->UpdateFCR31(mips_); +} + JitBlockCacheDebugInterface *IRNativeJit::GetBlockCacheDebugInterface() { return &debugInterface_; } diff --git a/Core/MIPS/IR/IRNativeCommon.h b/Core/MIPS/IR/IRNativeCommon.h index cef2c593e3..93273f6f0f 100644 --- a/Core/MIPS/IR/IRNativeCommon.h +++ b/Core/MIPS/IR/IRNativeCommon.h @@ -59,6 +59,8 @@ public: virtual void InvalidateBlock(IRBlock *block, int block_num) = 0; void FinalizeBlock(IRBlock *block, int block_num, const JitOptions &jo); + virtual void UpdateFCR31(MIPSState *mipsState) {} + const IRNativeHooks &GetNativeHooks() const { return hooks_; } @@ -168,6 +170,8 @@ public: const u8 *GetDispatcher() const override; const u8 *GetCrashHandler() const override; + void UpdateFCR31() override; + JitBlockCacheDebugInterface *GetBlockCacheDebugInterface() override; protected: diff --git a/Core/MIPS/JitCommon/JitCommon.cpp b/Core/MIPS/JitCommon/JitCommon.cpp index 48feebbbb5..259b500f0b 100644 --- a/Core/MIPS/JitCommon/JitCommon.cpp +++ b/Core/MIPS/JitCommon/JitCommon.cpp @@ -41,6 +41,7 @@ #include "../ARM/ArmJit.h" #elif PPSSPP_ARCH(ARM64) #include "../ARM64/Arm64Jit.h" +#include "../ARM64/Arm64IRJit.h" #elif PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64) #include "../x86/Jit.h" #include "../x86/X64IRJit.h" @@ -106,6 +107,8 @@ namespace MIPSComp { #if PPSSPP_ARCH(ARM) return new MIPSComp::ArmJit(mipsState); #elif PPSSPP_ARCH(ARM64) + if (useIR) + return new MIPSComp::Arm64IRJit(mipsState); return new MIPSComp::Arm64Jit(mipsState); #elif PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64) if (useIR) diff --git a/Core/MIPS/RiscV/RiscVJit.cpp b/Core/MIPS/RiscV/RiscVJit.cpp index be97dd4267..023687e47f 100644 --- a/Core/MIPS/RiscV/RiscVJit.cpp +++ b/Core/MIPS/RiscV/RiscVJit.cpp @@ -56,6 +56,8 @@ bool RiscVJitBackend::CompileBlock(IRBlock *block, int block_num, bool preload) if (GetSpaceLeft() < 0x800) return false; + BeginWrite(std::min(GetSpaceLeft(), (size_t)block->GetNumInstructions() * 32)); + u32 startPC = block->GetOriginalStart(); bool wroteCheckedOffset = false; if (jo.enableBlocklink && !jo.useBackJump) { @@ -151,6 +153,7 @@ bool RiscVJitBackend::CompileBlock(IRBlock *block, int block_num, bool preload) } } + EndWrite(); FlushIcache(); compilingBlockNum_ = -1; @@ -163,8 +166,6 @@ void RiscVJitBackend::WriteConstExit(uint32_t pc) { int exitStart = (int)GetOffset(GetCodePointer()); if (block_num >= 0 && jo.enableBlocklink && nativeBlock && nativeBlock->checkedOffset != 0) { - // Don't bother recording, we don't ever overwrite to "unlink". - // Instead, we would mark the target block to jump to the dispatcher. QuickJ(SCRATCH1, GetBasePtr() + nativeBlock->checkedOffset); } else { LI(SCRATCH1, pc); diff --git a/Core/MIPS/RiscV/RiscVRegCache.cpp b/Core/MIPS/RiscV/RiscVRegCache.cpp index 3e98406380..1c981eefd4 100644 --- a/Core/MIPS/RiscV/RiscVRegCache.cpp +++ b/Core/MIPS/RiscV/RiscVRegCache.cpp @@ -77,7 +77,6 @@ const int *RiscVRegCache::GetAllocationOrder(MIPSLoc type, MIPSMap flags, int &c } } else if (type == MIPSLoc::FREG) { // F8 through F15 are used for compression, so they are great. - // TODO: Maybe we could remove some saved regs since we rarely need that many? Or maybe worth it? static const int allocationOrder[] = { F8, F9, F10, F11, F12, F13, F14, F15, F0, F1, F2, F3, F4, F5, F6, F7, @@ -312,7 +311,6 @@ void RiscVRegCache::LoadNativeReg(IRNativeReg nreg, IRReg first, int lanes) { _dbg_assert_(r > X0); _dbg_assert_(first != MIPS_REG_ZERO); if (r <= X31) { - // Multilane not yet supported. _assert_(lanes == 1 || (lanes == 2 && first == IRREG_LO)); if (lanes == 1) emit_->LW(r, CTXREG, GetMipsRegOffset(first)); diff --git a/Core/MIPS/RiscV/RiscVRegCache.h b/Core/MIPS/RiscV/RiscVRegCache.h index a97a9fc169..facfa52195 100644 --- a/Core/MIPS/RiscV/RiscVRegCache.h +++ b/Core/MIPS/RiscV/RiscVRegCache.h @@ -44,7 +44,7 @@ public: void Init(RiscVGen::RiscVEmitter *emitter); // May fail and return INVALID_REG if it needs flushing. - RiscVGen::RiscVReg TryMapTempImm(IRReg); + RiscVGen::RiscVReg TryMapTempImm(IRReg reg); // Returns an RV register containing the requested MIPS register. RiscVGen::RiscVReg MapGPR(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); diff --git a/Core/MIPS/x86/X64IRCompALU.cpp b/Core/MIPS/x86/X64IRCompALU.cpp index e1621b3049..fc8d7c9b14 100644 --- a/Core/MIPS/x86/X64IRCompALU.cpp +++ b/Core/MIPS/x86/X64IRCompALU.cpp @@ -505,6 +505,7 @@ void X64JitBackend::CompIR_Logic(IRInst inst) { AND(32, regs_.R(inst.dest), regs_.R(inst.src2)); } break; + case IROp::Or: regs_.Map(inst); if (inst.dest == inst.src1) { diff --git a/Core/MIPS/x86/X64IRCompSystem.cpp b/Core/MIPS/x86/X64IRCompSystem.cpp index 91d4730773..5febc50ca6 100644 --- a/Core/MIPS/x86/X64IRCompSystem.cpp +++ b/Core/MIPS/x86/X64IRCompSystem.cpp @@ -219,7 +219,7 @@ int ReportBadAddress(uint32_t addr, uint32_t alignment, uint32_t isWrite) { return toss(MemoryExceptionType::ALIGNMENT); } return 0; -}; +} void X64JitBackend::CompIR_ValidateAddress(IRInst inst) { CONDITIONAL_DISABLE; diff --git a/Core/MIPS/x86/X64IRJit.cpp b/Core/MIPS/x86/X64IRJit.cpp index 75b11b4ceb..f70901eba8 100644 --- a/Core/MIPS/x86/X64IRJit.cpp +++ b/Core/MIPS/x86/X64IRJit.cpp @@ -166,8 +166,6 @@ void X64JitBackend::WriteConstExit(uint32_t pc) { int exitStart = (int)GetOffset(GetCodePointer()); if (block_num >= 0 && jo.enableBlocklink && nativeBlock && nativeBlock->checkedOffset != 0) { - // Don't bother recording, we don't ever overwrite to "unlink". - // Instead, we would mark the target block to jump to the dispatcher. JMP(GetBasePtr() + nativeBlock->checkedOffset, true); } else { MOV(32, R(SCRATCH1), Imm32(pc)); diff --git a/Core/MIPS/x86/X64IRJit.h b/Core/MIPS/x86/X64IRJit.h index b63d340485..6a2c09aef5 100644 --- a/Core/MIPS/x86/X64IRJit.h +++ b/Core/MIPS/x86/X64IRJit.h @@ -164,12 +164,12 @@ private: class X64IRJit : public IRNativeJit { public: X64IRJit(MIPSState *mipsState) - : IRNativeJit(mipsState), rvBackend_(jo, blocks_) { - Init(rvBackend_); + : IRNativeJit(mipsState), x64Backend_(jo, blocks_) { + Init(x64Backend_); } private: - X64JitBackend rvBackend_; + X64JitBackend x64Backend_; }; } // namespace MIPSComp diff --git a/Core/MIPS/x86/X64IRRegCache.cpp b/Core/MIPS/x86/X64IRRegCache.cpp index be98e5f244..387a64bdd1 100644 --- a/Core/MIPS/x86/X64IRRegCache.cpp +++ b/Core/MIPS/x86/X64IRRegCache.cpp @@ -262,7 +262,7 @@ void X64IRRegCache::MapWithFlags(IRInst inst, X64Map destFlags, X64Map src1Flags X64Reg X64IRRegCache::MapGPR(IRReg mipsReg, MIPSMap mapFlags) { _dbg_assert_(IsValidGPR(mipsReg)); - // Okay, not mapped, so we need to allocate an RV register. + // Okay, not mapped, so we need to allocate an x64 register. IRNativeReg nreg = MapNativeReg(MIPSLoc::REG, mipsReg, 1, mapFlags); return FromNativeReg(nreg); } @@ -270,7 +270,7 @@ X64Reg X64IRRegCache::MapGPR(IRReg mipsReg, MIPSMap mapFlags) { X64Reg X64IRRegCache::MapGPR2(IRReg mipsReg, MIPSMap mapFlags) { _dbg_assert_(IsValidGPR(mipsReg) && IsValidGPR(mipsReg + 1)); - // Okay, not mapped, so we need to allocate an RV register. + // Okay, not mapped, so we need to allocate an x64 register. IRNativeReg nreg = MapNativeReg(MIPSLoc::REG, mipsReg, 2, mapFlags); return FromNativeReg(nreg); } @@ -326,7 +326,6 @@ void X64IRRegCache::LoadNativeReg(IRNativeReg nreg, IRReg first, int lanes) { X64Reg r = FromNativeReg(nreg); _dbg_assert_(first != MIPS_REG_ZERO); if (nreg < NUM_X_REGS) { - // Multilane not yet supported. _assert_(lanes == 1 || (lanes == 2 && first == IRREG_LO)); if (lanes == 1) emit_->MOV(32, ::R(r), MDisp(CTXREG, -128 + GetMipsRegOffset(first))); @@ -354,7 +353,6 @@ void X64IRRegCache::StoreNativeReg(IRNativeReg nreg, IRReg first, int lanes) { X64Reg r = FromNativeReg(nreg); _dbg_assert_(first != MIPS_REG_ZERO); if (nreg < NUM_X_REGS) { - // Multilane not yet supported. _assert_(lanes == 1 || (lanes == 2 && first == IRREG_LO)); _assert_(mr[first].loc == MIPSLoc::REG || mr[first].loc == MIPSLoc::REG_IMM); if (lanes == 1) @@ -434,9 +432,9 @@ X64Reg X64IRRegCache::RXPtr(IRReg mipsReg) { if (mr[mipsReg].loc == MIPSLoc::REG_AS_PTR) { return FromNativeReg(mr[mipsReg].nReg); } else if (mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM) { - int rv = mr[mipsReg].nReg; - _dbg_assert_(nr[rv].pointerified); - if (nr[rv].pointerified) { + int r = mr[mipsReg].nReg; + _dbg_assert_(nr[r].pointerified); + if (nr[r].pointerified) { return FromNativeReg(mr[mipsReg].nReg); } else { ERROR_LOG(JIT, "Tried to use a non-pointer register as a pointer"); diff --git a/Core/MIPS/x86/X64IRRegCache.h b/Core/MIPS/x86/X64IRRegCache.h index 953c92e759..7cc580bb7a 100644 --- a/Core/MIPS/x86/X64IRRegCache.h +++ b/Core/MIPS/x86/X64IRRegCache.h @@ -78,9 +78,9 @@ public: void Init(Gen::XEmitter *emitter); // May fail and return INVALID_REG if it needs flushing. - Gen::X64Reg TryMapTempImm(IRReg, X64IRJitConstants::X64Map flags = X64IRJitConstants::X64Map::NONE); + Gen::X64Reg TryMapTempImm(IRReg reg, X64IRJitConstants::X64Map flags = X64IRJitConstants::X64Map::NONE); - // Returns an RV register containing the requested MIPS register. + // Returns an X64 register containing the requested MIPS register. Gen::X64Reg MapGPR(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); Gen::X64Reg MapGPR2(IRReg reg, MIPSMap mapFlags = MIPSMap::INIT); Gen::X64Reg MapGPRAsPointer(IRReg reg); diff --git a/UWP/CoreUWP/CoreUWP.vcxproj b/UWP/CoreUWP/CoreUWP.vcxproj index 298756b99f..d74fdbbb8d 100644 --- a/UWP/CoreUWP/CoreUWP.vcxproj +++ b/UWP/CoreUWP/CoreUWP.vcxproj @@ -271,6 +271,8 @@ + + @@ -520,6 +522,15 @@ + + + + + + + + + diff --git a/UWP/CoreUWP/CoreUWP.vcxproj.filters b/UWP/CoreUWP/CoreUWP.vcxproj.filters index 124e0d1284..b464f75271 100644 --- a/UWP/CoreUWP/CoreUWP.vcxproj.filters +++ b/UWP/CoreUWP/CoreUWP.vcxproj.filters @@ -782,6 +782,33 @@ MIPS\ARM64 + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + + + MIPS\ARM64 + HW @@ -1790,6 +1817,12 @@ MIPS\ARM64 + + MIPS\ARM64 + + + MIPS\ARM64 + HW diff --git a/android/jni/Android.mk b/android/jni/Android.mk index 95e98a34fb..338d52baa0 100644 --- a/android/jni/Android.mk +++ b/android/jni/Android.mk @@ -343,6 +343,15 @@ ARCH_FILES := \ $(SRC)/Core/MIPS/ARM64/Arm64Jit.cpp \ $(SRC)/Core/MIPS/ARM64/Arm64RegCache.cpp \ $(SRC)/Core/MIPS/ARM64/Arm64RegCacheFPU.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRAsm.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompALU.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompBranch.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompFPU.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompSystem.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRCompVec.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRJit.cpp \ + $(SRC)/Core/MIPS/ARM64/Arm64IRRegCache.cpp \ $(SRC)/Core/Util/DisArm64.cpp \ $(SRC)/GPU/Common/VertexDecoderArm64.cpp \ Arm64EmitterTest.cpp diff --git a/libretro/Makefile.common b/libretro/Makefile.common index f7c2c98a29..0168cd21e5 100644 --- a/libretro/Makefile.common +++ b/libretro/Makefile.common @@ -757,6 +757,15 @@ ifeq ($(WITH_DYNAREC),1) $(COREDIR)/MIPS/ARM64/Arm64Jit.cpp \ $(COREDIR)/MIPS/ARM64/Arm64RegCache.cpp \ $(COREDIR)/MIPS/ARM64/Arm64RegCacheFPU.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRAsm.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompALU.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompBranch.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompFPU.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompLoadStore.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompSystem.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRCompVec.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRJit.cpp \ + $(COREDIR)/MIPS/ARM64/Arm64IRRegCache.cpp \ $(COREDIR)/Util/DisArm64.cpp \ $(GPUCOMMONDIR)/VertexDecoderArm64.cpp From 76072808373114c47c64f3ed7a3a207bee1f60bd Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 12:20:16 -0700 Subject: [PATCH 23/40] arm64jit: Implement just the most basic ops. This improves the slowness a good bit. --- Core/MIPS/ARM64/Arm64IRCompALU.cpp | 27 +++++++++++++++++++++++++++ Core/MIPS/ARM64/Arm64IRCompSystem.cpp | 21 ++++++++++++++++++++- 2 files changed, 47 insertions(+), 1 deletion(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompALU.cpp b/Core/MIPS/ARM64/Arm64IRCompALU.cpp index f7cefcc723..b0b994db36 100644 --- a/Core/MIPS/ARM64/Arm64IRCompALU.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompALU.cpp @@ -51,8 +51,29 @@ void Arm64JitBackend::CompIR_Arith(IRInst inst) { switch (inst.op) { case IROp::Add: case IROp::Sub: + CompIR_Generic(inst); + break; + case IROp::AddConst: + if (regs_.IsGPRMappedAsPointer(inst.dest) && inst.dest == inst.src1 && allowPtrMath) { + regs_.MarkGPRAsPointerDirty(inst.dest); + ADDI2R(regs_.RPtr(inst.dest), regs_.RPtr(inst.src1), (int)inst.constant, SCRATCH1_64); + } else { + regs_.Map(inst); + ADDI2R(regs_.R(inst.dest), regs_.R(inst.src1), inst.constant, SCRATCH1); + } + break; + case IROp::SubConst: + if (regs_.IsGPRMappedAsPointer(inst.dest) && inst.dest == inst.src1 && allowPtrMath) { + regs_.MarkGPRAsPointerDirty(inst.dest); + SUBI2R(regs_.RPtr(inst.dest), regs_.RPtr(inst.src1), (int)inst.constant, SCRATCH1_64); + } else { + regs_.Map(inst); + SUBI2R(regs_.R(inst.dest), regs_.R(inst.src1), inst.constant, SCRATCH1); + } + break; + case IROp::Neg: CompIR_Generic(inst); break; @@ -68,6 +89,12 @@ void Arm64JitBackend::CompIR_Assign(IRInst inst) { switch (inst.op) { case IROp::Mov: + if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + break; + case IROp::Ext8to32: case IROp::Ext16to32: CompIR_Generic(inst); diff --git a/Core/MIPS/ARM64/Arm64IRCompSystem.cpp b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp index be4400f465..01ec22bcc5 100644 --- a/Core/MIPS/ARM64/Arm64IRCompSystem.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp @@ -47,11 +47,30 @@ void Arm64JitBackend::CompIR_Basic(IRInst inst) { switch (inst.op) { case IROp::Downcount: + SUBI2R(DOWNCOUNTREG, DOWNCOUNTREG, (s64)(s32)inst.constant, SCRATCH1); + break; + case IROp::SetConst: + regs_.SetGPRImm(inst.dest, inst.constant); + break; + case IROp::SetConstF: + { + regs_.Map(inst); + float f; + memcpy(&f, &inst.constant, sizeof(f)); + fp_.MOVI2F(regs_.F(inst.dest), f, SCRATCH1); + break; + } + case IROp::SetPC: + regs_.Map(inst); + MovToPC(regs_.R(inst.src1)); + break; + case IROp::SetPCConst: - CompIR_Generic(inst); + MOVI2R(SCRATCH1, inst.constant); + MovToPC(SCRATCH1); break; default: From e1a1f56f4cff8eaab4c566d1f54d0b0ea712ec86 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 2 Sep 2023 21:44:06 -0700 Subject: [PATCH 24/40] irjit: Cleanup breakpoint ops. --- Core/MIPS/IR/IRFrontend.cpp | 4 ++-- Core/MIPS/IR/IRInst.cpp | 4 ++-- Core/MIPS/IR/IRInterpreter.cpp | 24 +++++++++++++++++------- Core/MIPS/IR/IRInterpreter.h | 3 +++ 4 files changed, 24 insertions(+), 11 deletions(-) diff --git a/Core/MIPS/IR/IRFrontend.cpp b/Core/MIPS/IR/IRFrontend.cpp index 7cd47c3d11..38d54eb497 100644 --- a/Core/MIPS/IR/IRFrontend.cpp +++ b/Core/MIPS/IR/IRFrontend.cpp @@ -349,7 +349,7 @@ void IRFrontend::CheckBreakpoint(u32 addr) { ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); // Note that this means downcount can't be metadata on the block. js.downcountAmount = -downcountOffset; - ir.Write(IROp::Breakpoint); + ir.Write(IROp::Breakpoint, 0, ir.AddConstant(addr)); ApplyRoundingMode(); js.hadBreakpoints = true; @@ -372,7 +372,7 @@ void IRFrontend::CheckMemoryBreakpoint(int rs, int offset) { ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); // Note that this means downcount can't be metadata on the block. js.downcountAmount = -downcountOffset; - ir.Write(IROp::MemoryCheck, 0, rs, ir.AddConstant(offset)); + ir.Write(IROp::MemoryCheck, js.inDelaySlot ? 4 : 0, rs, ir.AddConstant(offset)); ApplyRoundingMode(); js.hadBreakpoints = true; diff --git a/Core/MIPS/IR/IRInst.cpp b/Core/MIPS/IR/IRInst.cpp index c03d1ec76f..5f9b4d53f0 100644 --- a/Core/MIPS/IR/IRInst.cpp +++ b/Core/MIPS/IR/IRInst.cpp @@ -166,8 +166,8 @@ static const IRMeta irMeta[] = { { IROp::SetPC, "SetPC", "_G" }, { IROp::SetPCConst, "SetPC", "_C" }, { IROp::CallReplacement, "CallRepl", "_C", IRFLAG_BARRIER }, - { IROp::Breakpoint, "Breakpoint", "", IRFLAG_BARRIER }, - { IROp::MemoryCheck, "MemoryCheck", "_GC", IRFLAG_BARRIER }, + { IROp::Breakpoint, "Breakpoint", "_C", IRFLAG_BARRIER }, + { IROp::MemoryCheck, "MemoryCheck", "IGC", IRFLAG_BARRIER }, { IROp::ValidateAddress8, "ValidAddr8", "_GC", IRFLAG_BARRIER }, { IROp::ValidateAddress16, "ValidAddr16", "_GC", IRFLAG_BARRIER }, diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index ade6d64b62..01c6f05d42 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -60,20 +60,30 @@ alignas(16) static const uint32_t lowBytesMask[4] = { 0x000000FF, 0x000000FF, 0x000000FF, 0x000000FF, }; -u32 RunBreakpoint(u32 pc) { +u32 IRRunBreakpoint(u32 pc) { // Should we skip this breakpoint? - if (CBreakPoints::CheckSkipFirst() == pc) + uint32_t skipFirst = CBreakPoints::CheckSkipFirst(); + if (skipFirst == pc || skipFirst == currentMIPS->pc) return 0; - CBreakPoints::ExecBreakPoint(currentMIPS->pc); + // Did we already hit one? + if (coreState != CORE_RUNNING && coreState != CORE_NEXTFRAME) + return 1; + + CBreakPoints::ExecBreakPoint(pc); return coreState != CORE_RUNNING ? 1 : 0; } -u32 RunMemCheck(u32 pc, u32 addr) { +u32 IRRunMemCheck(u32 pc, u32 addr) { // Should we skip this breakpoint? - if (CBreakPoints::CheckSkipFirst() == pc) + uint32_t skipFirst = CBreakPoints::CheckSkipFirst(); + if (skipFirst == pc || skipFirst == currentMIPS->pc) return 0; + // Did we already hit one? + if (coreState != CORE_RUNNING && coreState != CORE_NEXTFRAME) + return 1; + CBreakPoints::ExecOpMemCheck(addr, pc); return coreState != CORE_RUNNING ? 1 : 0; } @@ -1100,14 +1110,14 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, int count) { break; case IROp::Breakpoint: - if (RunBreakpoint(mips->pc)) { + if (IRRunBreakpoint(inst->constant)) { CoreTiming::ForceCheck(); return mips->pc; } break; case IROp::MemoryCheck: - if (RunMemCheck(mips->pc, mips->r[inst->src1] + inst->constant)) { + if (IRRunMemCheck(mips->pc + inst->dest, mips->r[inst->src1] + inst->constant)) { CoreTiming::ForceCheck(); return mips->pc; } diff --git a/Core/MIPS/IR/IRInterpreter.h b/Core/MIPS/IR/IRInterpreter.h index ec2c6f270b..21e7f15dc7 100644 --- a/Core/MIPS/IR/IRInterpreter.h +++ b/Core/MIPS/IR/IRInterpreter.h @@ -20,4 +20,7 @@ inline static u32 ReverseBits32(u32 v) { return v; } +u32 IRRunBreakpoint(u32 pc); +u32 IRRunMemCheck(u32 pc, u32 addr); + u32 IRInterpret(MIPSState *ms, const IRInst *inst, int count); From 259734bd471c3417a5f248874e047ac091eafbfb Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 2 Sep 2023 22:52:16 -0700 Subject: [PATCH 25/40] irjit: Fix likely delay slot breakpoints. --- Core/Debugger/Breakpoints.cpp | 2 +- Core/MIPS/IR/IRFrontend.cpp | 44 ++++++++++++++++++++++++---------- Core/MIPS/IR/IRInterpreter.cpp | 2 +- 3 files changed, 34 insertions(+), 14 deletions(-) diff --git a/Core/Debugger/Breakpoints.cpp b/Core/Debugger/Breakpoints.cpp index 3189acf76c..b02b35c7ad 100644 --- a/Core/Debugger/Breakpoints.cpp +++ b/Core/Debugger/Breakpoints.cpp @@ -311,7 +311,7 @@ BreakAction CBreakPoints::ExecBreakPoint(u32 addr) { std::unique_lock guard(breakPointsMutex_); size_t bp = FindBreakpoint(addr, false); if (bp != INVALID_BREAKPOINT) { - BreakPoint info = breakPoints_[bp]; + const BreakPoint &info = breakPoints_[bp]; guard.unlock(); if (info.hasCond) { diff --git a/Core/MIPS/IR/IRFrontend.cpp b/Core/MIPS/IR/IRFrontend.cpp index 38d54eb497..8243ac7b67 100644 --- a/Core/MIPS/IR/IRFrontend.cpp +++ b/Core/MIPS/IR/IRFrontend.cpp @@ -340,13 +340,24 @@ void IRFrontend::CheckBreakpoint(u32 addr) { if (CBreakPoints::IsAddressBreakPoint(addr)) { FlushAll(); + if (GetCompilerPC() != js.blockStart) + ir.Write(IROp::SetPCConst, 0, ir.AddConstant(GetCompilerPC())); + RestoreRoundingMode(); - ir.Write(IROp::SetPCConst, 0, ir.AddConstant(GetCompilerPC())); - // 0 because we normally execute before increasing. - // TODO: In likely branches, downcount will be incorrect. - int downcountOffset = js.inDelaySlot && js.downcountAmount >= 2 ? -2 : 0; + // At this point, downcount HAS the delay slot, but not the instruction itself. + int downcountOffset = 0; + if (js.inDelaySlot) { + MIPSOpcode branchOp = Memory::Read_Opcode_JIT(GetCompilerPC()); + MIPSOpcode delayOp = Memory::Read_Opcode_JIT(addr); + downcountOffset = -MIPSGetInstructionCycleEstimate(delayOp); + if ((MIPSGetInfo(branchOp) & LIKELY) != 0) { + // Okay, we're in a likely branch. Also negate the branch cycles. + downcountOffset += -MIPSGetInstructionCycleEstimate(branchOp); + } + } int downcountAmount = js.downcountAmount + downcountOffset; - ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); + if (downcountAmount != 0) + ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); // Note that this means downcount can't be metadata on the block. js.downcountAmount = -downcountOffset; ir.Write(IROp::Breakpoint, 0, ir.AddConstant(addr)); @@ -360,16 +371,25 @@ void IRFrontend::CheckMemoryBreakpoint(int rs, int offset) { if (CBreakPoints::HasMemChecks()) { FlushAll(); + if (GetCompilerPC() != js.blockStart) + ir.Write(IROp::SetPCConst, 0, ir.AddConstant(GetCompilerPC())); + RestoreRoundingMode(); - ir.Write(IROp::SetPCConst, 0, ir.AddConstant(GetCompilerPC())); - // 0 because we normally execute before increasing. - int downcountOffset = js.inDelaySlot ? -2 : -1; - // TODO: In likely branches, downcount will be incorrect. This might make resume fail. - if (js.downcountAmount == 0) { - downcountOffset = 0; + // At this point, downcount HAS the delay slot, but not the instruction itself. + int downcountOffset = 0; + if (js.inDelaySlot) { + // We assume delay slot in compilerPC + 4. + MIPSOpcode branchOp = Memory::Read_Opcode_JIT(GetCompilerPC()); + MIPSOpcode delayOp = Memory::Read_Opcode_JIT(GetCompilerPC() + 4); + downcountOffset = -MIPSGetInstructionCycleEstimate(delayOp); + if ((MIPSGetInfo(branchOp) & LIKELY) != 0) { + // Okay, we're in a likely branch. Also negate the branch cycles. + downcountOffset += -MIPSGetInstructionCycleEstimate(branchOp); + } } int downcountAmount = js.downcountAmount + downcountOffset; - ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); + if (downcountAmount != 0) + ir.Write(IROp::Downcount, 0, ir.AddConstant(downcountAmount)); // Note that this means downcount can't be metadata on the block. js.downcountAmount = -downcountOffset; ir.Write(IROp::MemoryCheck, js.inDelaySlot ? 4 : 0, rs, ir.AddConstant(offset)); diff --git a/Core/MIPS/IR/IRInterpreter.cpp b/Core/MIPS/IR/IRInterpreter.cpp index 01c6f05d42..8fa713d809 100644 --- a/Core/MIPS/IR/IRInterpreter.cpp +++ b/Core/MIPS/IR/IRInterpreter.cpp @@ -1053,7 +1053,7 @@ u32 IRInterpret(MIPSState *mips, const IRInst *inst, int count) { break; case IROp::Downcount: - mips->downcount -= inst->constant; + mips->downcount -= (int)inst->constant; break; case IROp::SetPC: From 60bcc5b0831bc7675531013e42896fa766c41fa0 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sat, 2 Sep 2023 22:52:57 -0700 Subject: [PATCH 26/40] x86jit: Handle breakpoints. Otherwise, we don't actually break until later, which isn't great. Could be more optimal, "rewinding" regcache state. --- Core/MIPS/x86/X64IRCompSystem.cpp | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/Core/MIPS/x86/X64IRCompSystem.cpp b/Core/MIPS/x86/X64IRCompSystem.cpp index 91d4730773..b4f9157c09 100644 --- a/Core/MIPS/x86/X64IRCompSystem.cpp +++ b/Core/MIPS/x86/X64IRCompSystem.cpp @@ -23,6 +23,7 @@ #include "Core/HLE/HLE.h" #include "Core/HLE/ReplaceTables.h" #include "Core/MemMap.h" +#include "Core/MIPS/IR/IRInterpreter.h" #include "Core/MIPS/x86/X64IRJit.h" #include "Core/MIPS/x86/X64IRRegCache.h" @@ -88,10 +89,26 @@ void X64JitBackend::CompIR_Breakpoint(IRInst inst) { switch (inst.op) { case IROp::Breakpoint: - case IROp::MemoryCheck: - CompIR_Generic(inst); + FlushAll(); + // Note: the constant could be a delay slot. + ABI_CallFunctionC((const void *)&IRRunBreakpoint, inst.constant); + TEST(32, R(EAX), R(EAX)); + J_CC(CC_NZ, dispatcherCheckCoreState_, true); break; + case IROp::MemoryCheck: + { + X64Reg addrBase = regs_.MapGPR(inst.src1); + FlushAll(); + LEA(32, addrBase, MDisp(addrBase, inst.constant)); + MovFromPC(SCRATCH1); + LEA(32, SCRATCH1, MDisp(SCRATCH1, inst.dest)); + ABI_CallFunctionRR((const void *)&IRRunMemCheck, SCRATCH1, addrBase); + TEST(32, R(EAX), R(EAX)); + J_CC(CC_NZ, dispatcherCheckCoreState_, true); + break; + } + default: INVALIDOP; break; From 1d152a1486783556c95b88de3124fe83ab096d8b Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 12:26:21 -0700 Subject: [PATCH 27/40] x86jit: Bake emuhack mask into jitbase. --- Core/MIPS/RiscV/RiscVRegCache.cpp | 4 ++++ Core/MIPS/x86/X64IRAsm.cpp | 18 +++++++++--------- Core/MIPS/x86/X64IRRegCache.h | 1 + 3 files changed, 14 insertions(+), 9 deletions(-) diff --git a/Core/MIPS/RiscV/RiscVRegCache.cpp b/Core/MIPS/RiscV/RiscVRegCache.cpp index 3e98406380..720cc40f81 100644 --- a/Core/MIPS/RiscV/RiscVRegCache.cpp +++ b/Core/MIPS/RiscV/RiscVRegCache.cpp @@ -206,6 +206,10 @@ RiscVGen::RiscVReg RiscVRegCache::Normalize32(IRReg mipsReg, RiscVGen::RiscVReg emit_->SEXT_W(destReg, (RiscVReg)mr[mipsReg].nReg); } break; + + default: + _assert_msg_(false, "Should not normalize32 floats"); + break; } return destReg == INVALID_REG ? reg : destReg; diff --git a/Core/MIPS/x86/X64IRAsm.cpp b/Core/MIPS/x86/X64IRAsm.cpp index 7705905298..2a5fb91152 100644 --- a/Core/MIPS/x86/X64IRAsm.cpp +++ b/Core/MIPS/x86/X64IRAsm.cpp @@ -56,15 +56,16 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { #if PPSSPP_ARCH(AMD64) bool jitbaseInR15 = false; int jitbaseCtxDisp = 0; - uintptr_t jitbase = (uintptr_t)GetBasePtr(); - if (jitbase > 0x7FFFFFFFULL && !Accessible((const u8 *)&mipsState->f[0], GetBasePtr())) { + // We pre-bake the MIPS_EMUHACK_OPCODE subtraction into our jitbase value. + intptr_t jitbase = (intptr_t)GetBasePtr() - MIPS_EMUHACK_OPCODE; + if ((jitbase < -0x80000000ULL || jitbase > 0x7FFFFFFFULL) && !Accessible((const u8 *)&mipsState->f[0], GetBasePtr())) { jo.reserveR15ForAsm = true; jitbaseInR15 = true; } else { jo.downcountInRegister = true; jo.reserveR15ForAsm = true; - if (jitbase > 0x7FFFFFFFULL) { - jitbaseCtxDisp = (int)(GetBasePtr() - (const u8 *)&mipsState->f[0]); + if (jitbase < -0x80000000ULL || jitbase > 0x7FFFFFFFULL) { + jitbaseCtxDisp = (int)(jitbase - (intptr_t)&mipsState->f[0]); } } #endif @@ -139,7 +140,7 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { // Two x64-specific statically allocated registers. MOV(64, R(MEMBASEREG), ImmPtr(Memory::base)); if (jitbaseInR15) - MOV(64, R(JITBASEREG), ImmPtr(GetBasePtr())); + MOV(64, R(JITBASEREG), ImmPtr((const void *)jitbase)); #endif // From the start of the FP reg, a single byte offset can reach all GPR + all FPR (but not VFPR.) MOV(PTRBITS, R(CTXREG), ImmPtr(&mipsState->f[0])); @@ -228,10 +229,9 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { CMP(32, R(EDX), Imm8(MIPS_EMUHACK_OPCODE >> 24)); } FixupBranch needsCompile = J_CC(CC_NE); - // Mask by 0x00FFFFFF and extract the block jit offset. - AND(32, R(SCRATCH1), Imm32(MIPS_EMUHACK_VALUE_MASK)); + // We don't mask here - that's baked into jitbase. #if PPSSPP_ARCH(X86) - LEA(32, SCRATCH1, MDisp(SCRATCH1, (u32)GetBasePtr())); + LEA(32, SCRATCH1, MDisp(SCRATCH1, (u32)GetBasePtr() - MIPS_EMUHACK_VALUE_MASK)); #elif PPSSPP_ARCH(AMD64) if (jitbaseInR15) { ADD(64, R(SCRATCH1), R(JITBASEREG)); @@ -239,7 +239,7 @@ void X64JitBackend::GenerateFixedCode(MIPSState *mipsState) { LEA(64, SCRATCH1, MComplex(CTXREG, SCRATCH1, SCALE_1, jitbaseCtxDisp)); } else { // See above, reserveR15ForAsm is used when above 0x7FFFFFFF. - LEA(64, SCRATCH1, MDisp(SCRATCH1, (u32)jitbase)); + LEA(64, SCRATCH1, MDisp(SCRATCH1, (s32)jitbase)); } #endif JMPptr(R(SCRATCH1)); diff --git a/Core/MIPS/x86/X64IRRegCache.h b/Core/MIPS/x86/X64IRRegCache.h index 953c92e759..4ff214f398 100644 --- a/Core/MIPS/x86/X64IRRegCache.h +++ b/Core/MIPS/x86/X64IRRegCache.h @@ -30,6 +30,7 @@ namespace X64IRJitConstants { #if PPSSPP_ARCH(AMD64) const Gen::X64Reg MEMBASEREG = Gen::RBX; const Gen::X64Reg CTXREG = Gen::R14; +// Note: this is actually offset from the base. const Gen::X64Reg JITBASEREG = Gen::R15; const Gen::X64Reg DOWNCOUNTREG = Gen::R15; #else From 0452b8b57a941635b90bbf281d58a328e8546081 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 13:29:05 -0700 Subject: [PATCH 28/40] riscv: Account for emuhack in JITBASEREG. --- Core/MIPS/RiscV/RiscVAsm.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Core/MIPS/RiscV/RiscVAsm.cpp b/Core/MIPS/RiscV/RiscVAsm.cpp index 2bbd420f4f..135e0604e8 100644 --- a/Core/MIPS/RiscV/RiscVAsm.cpp +++ b/Core/MIPS/RiscV/RiscVAsm.cpp @@ -121,7 +121,7 @@ void RiscVJitBackend::GenerateFixedCode(MIPSState *mipsState) { // Fixed registers, these are always kept when in Jit context. LI(MEMBASEREG, Memory::base, SCRATCH1); LI(CTXREG, mipsState, SCRATCH1); - LI(JITBASEREG, GetBasePtr(), SCRATCH1); + LI(JITBASEREG, GetBasePtr() - MIPS_EMUHACK_OPCODE, SCRATCH1); LoadStaticRegisters(); MovFromPC(SCRATCH1); @@ -173,9 +173,7 @@ void RiscVJitBackend::GenerateFixedCode(MIPSState *mipsState) { // We're in other words comparing to the top 8 bits of MIPS_EMUHACK_OPCODE by subtracting. ADDI(SCRATCH2, SCRATCH2, -(MIPS_EMUHACK_OPCODE >> 24)); FixupBranch needsCompile = BNE(SCRATCH2, R_ZERO); - // Use a wall to mask by 0x00FFFFFF and extract the block jit offset. - SLLI(SCRATCH1, SCRATCH1, XLEN - 24); - SRLI(SCRATCH1, SCRATCH1, XLEN - 24); + // No need to mask, JITBASEREG has already accounted for the upper bits. ADD(SCRATCH1, JITBASEREG, SCRATCH1); JR(SCRATCH1); SetJumpTarget(needsCompile); From 9439a433233e88779210f4796e3f5cb06bada41d Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 13:29:57 -0700 Subject: [PATCH 29/40] riscv: Correct an overlap case, fix assert. --- Core/MIPS/IR/IRRegCache.cpp | 5 +++-- Core/MIPS/RiscV/RiscVCompVec.cpp | 24 +++++++++++++++++++----- 2 files changed, 22 insertions(+), 7 deletions(-) diff --git a/Core/MIPS/IR/IRRegCache.cpp b/Core/MIPS/IR/IRRegCache.cpp index f2554bc630..698929a21a 100644 --- a/Core/MIPS/IR/IRRegCache.cpp +++ b/Core/MIPS/IR/IRRegCache.cpp @@ -784,10 +784,11 @@ void IRNativeRegCacheBase::ApplyMapping(const Mapping *mapping, int count) { return; } + bool mapSIMD = config_.mapFPUSIMD || mapping[i].type == 'G'; MIPSMap flags = mapping[i].flags; for (int j = 0; j < count; ++j) { if (mapping[j].type == mapping[i].type && mapping[j].reg == mapping[i].reg && i != j) { - _assert_msg_(mapping[j].lanes == mapping[i].lanes, "Lane aliasing not supported yet"); + _assert_msg_(!mapSIMD || mapping[j].lanes == mapping[i].lanes, "Lane aliasing not supported yet"); if (!isNoinit(mapping[j].flags) && isNoinit(flags)) { flags = (flags & MIPSMap::BACKEND_MASK) | MIPSMap::DIRTY; @@ -795,7 +796,7 @@ void IRNativeRegCacheBase::ApplyMapping(const Mapping *mapping, int count) { } } - if (config_.mapFPUSIMD || mapping[i].type == 'G') { + if (mapSIMD) { MapNativeReg(type, mapping[i].reg, mapping[i].lanes, flags); return; } diff --git a/Core/MIPS/RiscV/RiscVCompVec.cpp b/Core/MIPS/RiscV/RiscVCompVec.cpp index 8db60a76a8..3d91312a8c 100644 --- a/Core/MIPS/RiscV/RiscVCompVec.cpp +++ b/Core/MIPS/RiscV/RiscVCompVec.cpp @@ -35,6 +35,10 @@ namespace MIPSComp { using namespace RiscVGen; using namespace RiscVJitConstants; +static bool Overlap(IRReg r1, int l1, IRReg r2, int l2) { + return r1 < r2 + l2 && r1 + l1 > r2; +} + void RiscVJitBackend::CompIR_VecAssign(IRInst inst) { CONDITIONAL_DISABLE; @@ -215,10 +219,21 @@ void RiscVJitBackend::CompIR_VecArith(IRInst inst) { break; case IROp::Vec4Scale: - // TODO: This works for now, but may need to handle aliasing for vectors. regs_.Map(inst); - for (int i = 0; i < 4; ++i) - FMUL(32, regs_.F(inst.dest + i), regs_.F(inst.src1 + i), regs_.F(inst.src2)); + if (Overlap(inst.src2, 1, inst.dest, 3)) { + // We have to handle overlap, doing dest == src2 last. + for (int i = 0; i < 4; ++i) { + if (inst.src2 != inst.dest + i) + FMUL(32, regs_.F(inst.dest + i), regs_.F(inst.src1 + i), regs_.F(inst.src2)); + } + for (int i = 0; i < 4; ++i) { + if (inst.src2 == inst.dest + i) + FMUL(32, regs_.F(inst.dest + i), regs_.F(inst.src1 + i), regs_.F(inst.src2)); + } + } else { + for (int i = 0; i < 4; ++i) + FMUL(32, regs_.F(inst.dest + i), regs_.F(inst.src1 + i), regs_.F(inst.src2)); + } break; case IROp::Vec4Neg: @@ -244,9 +259,8 @@ void RiscVJitBackend::CompIR_VecHoriz(IRInst inst) { switch (inst.op) { case IROp::Vec4Dot: - // TODO: This works for now, but may need to handle aliasing for vectors. regs_.Map(inst); - if ((inst.dest < inst.src1 + 4 && inst.dest >= inst.src1) || (inst.dest < inst.src2 + 4 && inst.dest >= inst.src2)) { + if (Overlap(inst.dest, 1, inst.src1, 4) || Overlap(inst.dest, 1, inst.src2, 4)) { // This means inst.dest overlaps one of src1 or src2. We have to do that one first. // Technically this may impact -0.0 and such, but dots accurately need to be aligned anyway. for (int i = 0; i < 4; ++i) { From c44f0e1fca0c1db0b60b28368a1660ed0205b6d5 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 15:30:55 -0700 Subject: [PATCH 30/40] arm64jit: Implement most ALU in IR jit. --- Core/MIPS/ARM64/Arm64IRCompALU.cpp | 223 ++++++++++++++++++++++++++-- Core/MIPS/ARM64/Arm64IRRegCache.cpp | 4 + Core/MIPS/ARM64/Arm64IRRegCache.h | 1 + 3 files changed, 217 insertions(+), 11 deletions(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompALU.cpp b/Core/MIPS/ARM64/Arm64IRCompALU.cpp index b0b994db36..7f9e734e35 100644 --- a/Core/MIPS/ARM64/Arm64IRCompALU.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompALU.cpp @@ -50,8 +50,13 @@ void Arm64JitBackend::CompIR_Arith(IRInst inst) { switch (inst.op) { case IROp::Add: + regs_.Map(inst); + ADD(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + break; + case IROp::Sub: - CompIR_Generic(inst); + regs_.Map(inst); + SUB(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); break; case IROp::AddConst: @@ -75,7 +80,8 @@ void Arm64JitBackend::CompIR_Arith(IRInst inst) { break; case IROp::Neg: - CompIR_Generic(inst); + regs_.Map(inst); + NEG(regs_.R(inst.dest), regs_.R(inst.src1)); break; default: @@ -96,8 +102,13 @@ void Arm64JitBackend::CompIR_Assign(IRInst inst) { break; case IROp::Ext8to32: + regs_.Map(inst); + SXTB(regs_.R(inst.dest), regs_.R(inst.src1)); + break; + case IROp::Ext16to32: - CompIR_Generic(inst); + regs_.Map(inst); + SXTH(regs_.R(inst.dest), regs_.R(inst.src1)); break; default: @@ -110,11 +121,24 @@ void Arm64JitBackend::CompIR_Bits(IRInst inst) { CONDITIONAL_DISABLE; switch (inst.op) { - case IROp::BSwap32: - case IROp::ReverseBits: case IROp::BSwap16: + regs_.Map(inst); + REV16(regs_.R(inst.dest), regs_.R(inst.src1)); + break; + + case IROp::BSwap32: + regs_.Map(inst); + REV32(regs_.R(inst.dest), regs_.R(inst.src1)); + break; + case IROp::Clz: - CompIR_Generic(inst); + regs_.Map(inst); + CLZ(regs_.R(inst.dest), regs_.R(inst.src1)); + break; + + case IROp::ReverseBits: + regs_.Map(inst); + RBIT(regs_.R(inst.dest), regs_.R(inst.src1)); break; default: @@ -128,10 +152,37 @@ void Arm64JitBackend::CompIR_Compare(IRInst inst) { switch (inst.op) { case IROp::Slt: + regs_.Map(inst); + CMP(regs_.R(inst.src1), regs_.R(inst.src2)); + CSET(regs_.R(inst.dest), CC_LT); + break; + case IROp::SltConst: + if (inst.constant == 0) { + // Basically, getting the sign bit. + regs_.Map(inst); + UBFX(regs_.R(inst.dest), regs_.R(inst.src1), 31, 1); + } else { + regs_.Map(inst); + CMPI2R(regs_.R(inst.src1), (int32_t)inst.constant, SCRATCH1); + CSET(regs_.R(inst.dest), CC_LT); + } + break; + case IROp::SltU: + regs_.Map(inst); + CMP(regs_.R(inst.src1), regs_.R(inst.src2)); + CSET(regs_.R(inst.dest), CC_LO); + break; + case IROp::SltUConst: - CompIR_Generic(inst); + if (inst.constant == 0) { + regs_.SetGPRImm(inst.dest, 0); + } else { + regs_.Map(inst); + CMPI2R(regs_.R(inst.src1), (int32_t)inst.constant, SCRATCH1); + CSET(regs_.R(inst.dest), CC_LO); + } break; default: @@ -145,10 +196,41 @@ void Arm64JitBackend::CompIR_CondAssign(IRInst inst) { switch (inst.op) { case IROp::MovZ: + if (inst.dest != inst.src2) { + regs_.Map(inst); + CMP(regs_.R(inst.src1), 0); + CSEL(regs_.R(inst.dest), regs_.R(inst.src2), regs_.R(inst.dest), CC_EQ); + } + break; + case IROp::MovNZ: + if (inst.dest != inst.src2) { + regs_.Map(inst); + CMP(regs_.R(inst.src1), 0); + CSEL(regs_.R(inst.dest), regs_.R(inst.src2), regs_.R(inst.dest), CC_NEQ); + } + break; + case IROp::Max: + if (inst.src1 != inst.src2) { + regs_.Map(inst); + CMP(regs_.R(inst.src1), regs_.R(inst.src2)); + CSEL(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2), CC_GE); + } else if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + break; + case IROp::Min: - CompIR_Generic(inst); + if (inst.src1 != inst.src2) { + regs_.Map(inst); + CMP(regs_.R(inst.src1), regs_.R(inst.src2)); + CSEL(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2), CC_LE); + } else if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } break; default: @@ -177,10 +259,23 @@ void Arm64JitBackend::CompIR_HiLo(IRInst inst) { switch (inst.op) { case IROp::MtLo: + regs_.MapWithExtra(inst, { { 'G', IRREG_LO, 2, MIPSMap::DIRTY } }); + BFI(regs_.R64(IRREG_LO), regs_.R64(inst.src1), 0, 32); + break; + case IROp::MtHi: + regs_.MapWithExtra(inst, { { 'G', IRREG_LO, 2, MIPSMap::DIRTY } }); + BFI(regs_.R64(IRREG_LO), regs_.R64(inst.src1), 32, 32); + break; + case IROp::MfLo: + regs_.MapWithExtra(inst, { { 'G', IRREG_LO, 2, MIPSMap::INIT } }); + MOV(regs_.R(inst.dest), regs_.R(IRREG_LO)); + break; + case IROp::MfHi: - CompIR_Generic(inst); + regs_.MapWithExtra(inst, { { 'G', IRREG_LO, 2, MIPSMap::INIT } }); + UBFX(regs_.R64(inst.dest), regs_.R64(IRREG_LO), 32, 32); break; default: @@ -194,13 +289,52 @@ void Arm64JitBackend::CompIR_Logic(IRInst inst) { switch (inst.op) { case IROp::And: + if (inst.src1 != inst.src2) { + regs_.Map(inst); + AND(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + } else if (inst.src1 != inst.dest) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + break; + case IROp::Or: + if (inst.src1 != inst.src2) { + regs_.Map(inst); + ORR(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + } else if (inst.src1 != inst.dest) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + break; + case IROp::Xor: + if (inst.src1 == inst.src2) { + regs_.SetGPRImm(inst.dest, 0); + } else { + regs_.Map(inst); + EOR(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + } + break; + case IROp::AndConst: + regs_.Map(inst); + ANDI2R(regs_.R(inst.dest), regs_.R(inst.src1), inst.constant, SCRATCH1); + break; + case IROp::OrConst: + regs_.Map(inst); + ORRI2R(regs_.R(inst.dest), regs_.R(inst.src1), inst.constant, SCRATCH1); + break; + case IROp::XorConst: + regs_.Map(inst); + EORI2R(regs_.R(inst.dest), regs_.R(inst.src1), inst.constant, SCRATCH1); + break; + case IROp::Not: - CompIR_Generic(inst); + regs_.Map(inst); + MVN(regs_.R(inst.dest), regs_.R(inst.src1)); break; default: @@ -233,14 +367,81 @@ void Arm64JitBackend::CompIR_Shift(IRInst inst) { switch (inst.op) { case IROp::Shl: + regs_.Map(inst); + LSLV(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + break; + case IROp::Shr: + regs_.Map(inst); + LSRV(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + break; + case IROp::Sar: + regs_.Map(inst); + ASRV(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + break; + case IROp::Ror: + regs_.Map(inst); + RORV(regs_.R(inst.dest), regs_.R(inst.src1), regs_.R(inst.src2)); + break; + case IROp::ShlImm: + // Shouldn't happen, but let's be safe of any passes that modify the ops. + if (inst.src2 >= 32) { + regs_.SetGPRImm(inst.dest, 0); + } else if (inst.src2 == 0) { + if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + } else { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1), ArithOption(regs_.R(inst.src1), ST_LSL, inst.src2)); + } + break; + case IROp::ShrImm: + // Shouldn't happen, but let's be safe of any passes that modify the ops. + if (inst.src2 >= 32) { + regs_.SetGPRImm(inst.dest, 0); + } else if (inst.src2 == 0) { + if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + } else { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1), ArithOption(regs_.R(inst.src1), ST_LSR, inst.src2)); + } + break; + case IROp::SarImm: + // Shouldn't happen, but let's be safe of any passes that modify the ops. + if (inst.src2 >= 32) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1), ArithOption(regs_.R(inst.src1), ST_ASR, 31)); + } else if (inst.src2 == 0) { + if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + } else { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1), ArithOption(regs_.R(inst.src1), ST_ASR, inst.src2)); + } + break; + case IROp::RorImm: - CompIR_Generic(inst); + if (inst.src2 == 0) { + if (inst.dest != inst.src1) { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1)); + } + } else { + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(inst.src1), ArithOption(regs_.R(inst.src1), ST_ROR, inst.src2 & 31)); + } break; default: diff --git a/Core/MIPS/ARM64/Arm64IRRegCache.cpp b/Core/MIPS/ARM64/Arm64IRRegCache.cpp index f65e418d53..37b7078ce6 100644 --- a/Core/MIPS/ARM64/Arm64IRRegCache.cpp +++ b/Core/MIPS/ARM64/Arm64IRRegCache.cpp @@ -514,6 +514,10 @@ ARM64Reg Arm64IRRegCache::R(IRReg mipsReg) { } } +ARM64Reg Arm64IRRegCache::R64(IRReg mipsReg) { + return EncodeRegTo64(R(mipsReg)); +} + ARM64Reg Arm64IRRegCache::RPtr(IRReg mipsReg) { _dbg_assert_(IsValidGPR(mipsReg)); _dbg_assert_(mr[mipsReg].loc == MIPSLoc::REG || mr[mipsReg].loc == MIPSLoc::REG_IMM || mr[mipsReg].loc == MIPSLoc::REG_AS_PTR); diff --git a/Core/MIPS/ARM64/Arm64IRRegCache.h b/Core/MIPS/ARM64/Arm64IRRegCache.h index 89e570d643..8ecb337e4d 100644 --- a/Core/MIPS/ARM64/Arm64IRRegCache.h +++ b/Core/MIPS/ARM64/Arm64IRRegCache.h @@ -70,6 +70,7 @@ public: Arm64Gen::ARM64Reg GetAndLockTempFPR(); Arm64Gen::ARM64Reg R(IRReg preg); // Returns a cached register, while checking that it's NOT mapped as a pointer + Arm64Gen::ARM64Reg R64(IRReg preg); Arm64Gen::ARM64Reg RPtr(IRReg preg); // Returns a cached register, if it has been mapped as a pointer Arm64Gen::ARM64Reg F(IRReg preg); Arm64Gen::ARM64Reg FD(IRReg preg); From 1042737c2149ca1464899a159d0b9e9f5b8f8c70 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 21:13:11 -0700 Subject: [PATCH 31/40] irjit: Correct metadata on Vec2 packing ops. --- Core/MIPS/IR/IRInst.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Core/MIPS/IR/IRInst.cpp b/Core/MIPS/IR/IRInst.cpp index 5f9b4d53f0..3db8c4e4e2 100644 --- a/Core/MIPS/IR/IRInst.cpp +++ b/Core/MIPS/IR/IRInst.cpp @@ -147,8 +147,8 @@ static const IRMeta irMeta[] = { { IROp::Vec2ClampToZero, "Vec2ClampToZero", "22" }, { IROp::Vec4Pack32To8, "Vec4Pack32To8", "FV" }, { IROp::Vec4Pack31To8, "Vec4Pack31To8", "FV" }, - { IROp::Vec2Pack32To16, "Vec2Pack32To16", "2V" }, - { IROp::Vec2Pack31To16, "Vec2Pack31To16", "2V" }, + { IROp::Vec2Pack32To16, "Vec2Pack32To16", "F2" }, + { IROp::Vec2Pack31To16, "Vec2Pack31To16", "F2" }, { IROp::Interpret, "Interpret", "_C", IRFLAG_BARRIER }, { IROp::Downcount, "Downcount", "_C" }, From 87b96332588fa589390f7dde4f4c68932c536a0f Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 20:30:23 -0700 Subject: [PATCH 32/40] arm64jit: Add some simple float ops. --- Core/MIPS/ARM64/Arm64IRCompFPU.cpp | 33 +++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompFPU.cpp b/Core/MIPS/ARM64/Arm64IRCompFPU.cpp index c3000b5969..27f7b40a82 100644 --- a/Core/MIPS/ARM64/Arm64IRCompFPU.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompFPU.cpp @@ -46,12 +46,33 @@ void Arm64JitBackend::CompIR_FArith(IRInst inst) { switch (inst.op) { case IROp::FAdd: + regs_.Map(inst); + fp_.FADD(regs_.F(inst.dest), regs_.F(inst.src1), regs_.F(inst.src2)); + break; + case IROp::FSub: + regs_.Map(inst); + fp_.FSUB(regs_.F(inst.dest), regs_.F(inst.src1), regs_.F(inst.src2)); + break; + case IROp::FMul: + regs_.Map(inst); + fp_.FMUL(regs_.F(inst.dest), regs_.F(inst.src1), regs_.F(inst.src2)); + break; + case IROp::FDiv: + regs_.Map(inst); + fp_.FDIV(regs_.F(inst.dest), regs_.F(inst.src1), regs_.F(inst.src2)); + break; + case IROp::FSqrt: + regs_.Map(inst); + fp_.FSQRT(regs_.F(inst.dest), regs_.F(inst.src1)); + break; + case IROp::FNeg: - CompIR_Generic(inst); + regs_.Map(inst); + fp_.FNEG(regs_.F(inst.dest), regs_.F(inst.src1)); break; default: @@ -65,7 +86,17 @@ void Arm64JitBackend::CompIR_FAssign(IRInst inst) { switch (inst.op) { case IROp::FMov: + if (inst.dest != inst.src1) { + regs_.Map(inst); + fp_.FMOV(regs_.F(inst.dest), regs_.F(inst.src1)); + } + break; + case IROp::FAbs: + regs_.Map(inst); + fp_.FABS(regs_.F(inst.dest), regs_.F(inst.src1)); + break; + case IROp::FSign: CompIR_Generic(inst); break; From 0933381b9e65330316b41ac55cd5e65264ebfede Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 21:12:12 -0700 Subject: [PATCH 33/40] arm64jit: Add some simple vec4 ops. --- Core/MIPS/ARM64/Arm64IRCompVec.cpp | 34 +++++++++++++++++++++++++++--- 1 file changed, 31 insertions(+), 3 deletions(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompVec.cpp b/Core/MIPS/ARM64/Arm64IRCompVec.cpp index e4fe133e3d..8cd3331ddb 100644 --- a/Core/MIPS/ARM64/Arm64IRCompVec.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompVec.cpp @@ -45,15 +45,39 @@ void Arm64JitBackend::CompIR_VecArith(IRInst inst) { switch (inst.op) { case IROp::Vec4Add: + regs_.Map(inst); + fp_.FADD(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1), regs_.FQ(inst.src2)); + break; + case IROp::Vec4Sub: + regs_.Map(inst); + fp_.FSUB(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1), regs_.FQ(inst.src2)); + break; + case IROp::Vec4Mul: + regs_.Map(inst); + fp_.FMUL(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1), regs_.FQ(inst.src2)); + break; + case IROp::Vec4Div: + regs_.Map(inst); + fp_.FDIV(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1), regs_.FQ(inst.src2)); + break; + case IROp::Vec4Scale: - case IROp::Vec4Neg: - case IROp::Vec4Abs: CompIR_Generic(inst); break; + case IROp::Vec4Neg: + regs_.Map(inst); + fp_.FNEG(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1)); + break; + + case IROp::Vec4Abs: + regs_.Map(inst); + fp_.FABS(32, regs_.FQ(inst.dest), regs_.FQ(inst.src1)); + break; + default: INVALIDOP; break; @@ -67,10 +91,14 @@ void Arm64JitBackend::CompIR_VecAssign(IRInst inst) { case IROp::Vec4Init: case IROp::Vec4Shuffle: case IROp::Vec4Blend: - case IROp::Vec4Mov: CompIR_Generic(inst); break; + case IROp::Vec4Mov: + regs_.Map(inst); + fp_.MOV(regs_.FQ(inst.dest), regs_.FQ(inst.src1)); + break; + default: INVALIDOP; break; From e02426cbbff5a88130d2d3ac1533bf486ad35c45 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 18:41:41 -0700 Subject: [PATCH 34/40] arm64jit: Implement some system ops. --- Core/MIPS/ARM64/Arm64IRCompSystem.cpp | 95 ++++++++++++++++++++++++++- Core/MIPS/RiscV/RiscVCompSystem.cpp | 2 +- 2 files changed, 94 insertions(+), 3 deletions(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompSystem.cpp b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp index 01ec22bcc5..8b2af1734a 100644 --- a/Core/MIPS/ARM64/Arm64IRCompSystem.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompSystem.cpp @@ -99,9 +99,52 @@ void Arm64JitBackend::CompIR_System(IRInst inst) { switch (inst.op) { case IROp::Syscall: + FlushAll(); + SaveStaticRegisters(); + +#ifdef USE_PROFILER + // When profiling, we can't skip CallSyscall, since it times syscalls. + MOVI2R(W0, inst.constant); + QuickCallFunction(SCRATCH2_64, &CallSyscall); +#else + // Skip the CallSyscall where possible. + { + MIPSOpcode op(inst.constant); + void *quickFunc = GetQuickSyscallFunc(op); + if (quickFunc) { + MOVP2R(X0, GetSyscallFuncPointer(op)); + QuickCallFunction(SCRATCH2_64, (const u8 *)quickFunc); + } else { + MOVI2R(W0, inst.constant); + QuickCallFunction(SCRATCH2_64, &CallSyscall); + } + } +#endif + + LoadStaticRegisters(); + // This is always followed by an ExitToPC, where we check coreState. + break; + case IROp::CallReplacement: + FlushAll(); + SaveStaticRegisters(); + QuickCallFunction(SCRATCH2_64, GetReplacementFunc(inst.constant)->replaceFunc); + LoadStaticRegisters(); + SUB(DOWNCOUNTREG, DOWNCOUNTREG, W0); + break; + case IROp::Break: - CompIR_Generic(inst); + FlushAll(); + // This doesn't naturally have restore/apply around it. + RestoreRoundingMode(true); + SaveStaticRegisters(); + MovFromPC(W0); + QuickCallFunction(SCRATCH2_64, &Core_Break); + LoadStaticRegisters(); + ApplyRoundingMode(true); + MovFromPC(SCRATCH1); + ADDI2R(SCRATCH1, SCRATCH1, 4, SCRATCH2); + B(dispatcherPCInSCRATCH1_); break; default: @@ -115,16 +158,64 @@ void Arm64JitBackend::CompIR_Transfer(IRInst inst) { switch (inst.op) { case IROp::SetCtrlVFPU: + regs_.SetGPRImm(IRREG_VFPU_CTRL_BASE + inst.dest, inst.constant); + break; + case IROp::SetCtrlVFPUReg: + regs_.Map(inst); + MOV(regs_.R(IRREG_VFPU_CTRL_BASE + inst.dest), regs_.R(inst.src1)); + break; + case IROp::SetCtrlVFPUFReg: + regs_.Map(inst); + fp_.FMOV(regs_.R(IRREG_VFPU_CTRL_BASE + inst.dest), regs_.F(inst.src1)); + break; + case IROp::FpCondFromReg: + regs_.MapWithExtra(inst, { { 'G', IRREG_FPCOND, 1, MIPSMap::NOINIT } }); + MOV(regs_.R(IRREG_FPCOND), regs_.R(inst.src1)); + break; + case IROp::FpCondToReg: + regs_.MapWithExtra(inst, { { 'G', IRREG_FPCOND, 1, MIPSMap::INIT } }); + MOV(regs_.R(inst.dest), regs_.R(IRREG_FPCOND)); + break; + case IROp::FpCtrlFromReg: + regs_.MapWithExtra(inst, { { 'G', IRREG_FPCOND, 1, MIPSMap::NOINIT } }); + ANDI2R(SCRATCH1, regs_.R(inst.src1), 0x0181FFFF, SCRATCH2); + // Extract the new fpcond value. + UBFX(regs_.R(IRREG_FPCOND), SCRATCH1, 23, 1); + STR(INDEX_UNSIGNED, SCRATCH1, CTXREG, IRREG_FCR31 * 4); + break; + case IROp::FpCtrlToReg: + regs_.MapWithExtra(inst, { { 'G', IRREG_FPCOND, 1, MIPSMap::INIT } }); + // Load fcr31 and clear the fpcond bit. + LDR(INDEX_UNSIGNED, regs_.R(inst.dest), CTXREG, IRREG_FCR31 * 4); + BFI(regs_.R(inst.dest), regs_.R(IRREG_FPCOND), 23, 1); + // Also update mips->fcr31 while we're here. + STR(INDEX_UNSIGNED, regs_.R(inst.dest), CTXREG, IRREG_FCR31 * 4); + break; + case IROp::VfpuCtrlToReg: + regs_.Map(inst); + MOV(regs_.R(inst.dest), regs_.R(IRREG_VFPU_CTRL_BASE + inst.src1)); + break; + case IROp::FMovFromGPR: + if (regs_.IsGPRImm(inst.src1) && regs_.GetGPRImm(inst.src1) == 0) { + regs_.MapFPR(inst.dest, MIPSMap::NOINIT); + fp_.MOVI2F(regs_.F(inst.dest), 0.0f, SCRATCH1); + } else { + regs_.Map(inst); + fp_.FMOV(regs_.F(inst.dest), regs_.R(inst.src1)); + } + break; + case IROp::FMovToGPR: - CompIR_Generic(inst); + regs_.Map(inst); + fp_.FMOV(regs_.R(inst.dest), regs_.F(inst.src1)); break; default: diff --git a/Core/MIPS/RiscV/RiscVCompSystem.cpp b/Core/MIPS/RiscV/RiscVCompSystem.cpp index ff6de6786f..878687e64d 100644 --- a/Core/MIPS/RiscV/RiscVCompSystem.cpp +++ b/Core/MIPS/RiscV/RiscVCompSystem.cpp @@ -90,7 +90,7 @@ void RiscVJitBackend::CompIR_Transfer(IRInst inst) { switch (inst.op) { case IROp::SetCtrlVFPU: - regs_.SetGPRImm(IRREG_VFPU_CTRL_BASE + inst.dest, (int32_t)inst.constant); + regs_.SetGPRImm(IRREG_VFPU_CTRL_BASE + inst.dest, inst.constant); break; case IROp::SetCtrlVFPUReg: From ccee8e41eea72773957e7d159fa94e8b46fb5045 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 19:01:15 -0700 Subject: [PATCH 35/40] arm64jit: Implement exits. --- Core/MIPS/ARM64/Arm64IRCompBranch.cpp | 87 ++++++++++++++++++++++++++- 1 file changed, 85 insertions(+), 2 deletions(-) diff --git a/Core/MIPS/ARM64/Arm64IRCompBranch.cpp b/Core/MIPS/ARM64/Arm64IRCompBranch.cpp index a14bc6c325..c7bb4ae110 100644 --- a/Core/MIPS/ARM64/Arm64IRCompBranch.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompBranch.cpp @@ -40,11 +40,23 @@ using namespace Arm64IRJitConstants; void Arm64JitBackend::CompIR_Exit(IRInst inst) { CONDITIONAL_DISABLE; + ARM64Reg exitReg = INVALID_REG; switch (inst.op) { case IROp::ExitToConst: + FlushAll(); + WriteConstExit(inst.constant); + break; + case IROp::ExitToReg: + exitReg = regs_.MapGPR(inst.src1); + FlushAll(); + MOV(SCRATCH1, exitReg); + B(dispatcherPCInSCRATCH1_); + break; + case IROp::ExitToPC: - CompIR_Generic(inst); + FlushAll(); + B(dispatcherCheckCoreState_); break; default: @@ -56,14 +68,85 @@ void Arm64JitBackend::CompIR_Exit(IRInst inst) { void Arm64JitBackend::CompIR_ExitIf(IRInst inst) { CONDITIONAL_DISABLE; + ARM64Reg lhs = INVALID_REG; + ARM64Reg rhs = INVALID_REG; + FixupBranch fixup; switch (inst.op) { case IROp::ExitToConstIfEq: case IROp::ExitToConstIfNeq: + if (regs_.IsGPRImm(inst.src1) && regs_.GetGPRImm(inst.src1) == 0) { + lhs = regs_.MapGPR(inst.src2); + FlushAll(); + + if (inst.op == IROp::ExitToConstIfEq) + fixup = CBNZ(lhs); + else if (inst.op == IROp::ExitToConstIfNeq) + fixup = CBZ(lhs); + else + _assert_(false); + } else if (regs_.IsGPRImm(inst.src2) && regs_.GetGPRImm(inst.src2) == 0) { + lhs = regs_.MapGPR(inst.src1); + FlushAll(); + + if (inst.op == IROp::ExitToConstIfEq) + fixup = CBNZ(lhs); + else if (inst.op == IROp::ExitToConstIfNeq) + fixup = CBZ(lhs); + else + _assert_(false); + } else { + regs_.Map(inst); + lhs = regs_.R(inst.src1); + rhs = regs_.R(inst.src2); + FlushAll(); + + CMP(lhs, rhs); + if (inst.op == IROp::ExitToConstIfEq) + fixup = B(CC_NEQ); + else if (inst.op == IROp::ExitToConstIfNeq) + fixup = B(CC_EQ); + else + _assert_(false); + } + + WriteConstExit(inst.constant); + SetJumpTarget(fixup); + break; + case IROp::ExitToConstIfGtZ: + lhs = regs_.MapGPR(inst.src1); + FlushAll(); + CMP(lhs, 0); + fixup = B(CC_LE); + WriteConstExit(inst.constant); + SetJumpTarget(fixup); + break; + case IROp::ExitToConstIfGeZ: + // In other words, exit if sign bit is 0. + lhs = regs_.MapGPR(inst.src1); + FlushAll(); + fixup = TBNZ(lhs, 31); + WriteConstExit(inst.constant); + SetJumpTarget(fixup); + break; + case IROp::ExitToConstIfLtZ: + // In other words, exit if sign bit is 1. + lhs = regs_.MapGPR(inst.src1); + FlushAll(); + fixup = TBZ(lhs, 31); + WriteConstExit(inst.constant); + SetJumpTarget(fixup); + break; + case IROp::ExitToConstIfLeZ: - CompIR_Generic(inst); + lhs = regs_.MapGPR(inst.src1); + FlushAll(); + CMP(lhs, 0); + fixup = B(CC_GT); + WriteConstExit(inst.constant); + SetJumpTarget(fixup); break; case IROp::ExitToConstIfFpTrue: From 85b80bc9e5786169f6e477fee1a78669968116f6 Mon Sep 17 00:00:00 2001 From: "Unknown W. Brackets" Date: Sun, 3 Sep 2023 17:37:33 -0700 Subject: [PATCH 36/40] arm64jit: Implement load/store in IR. --- Common/Arm64Emitter.h | 17 ++ Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp | 288 ++++++++++++++++++++++- Core/MIPS/ARM64/Arm64IRJit.h | 10 + Core/MIPS/RiscV/RiscVCompLoadStore.cpp | 4 + Core/MIPS/x86/X64IRCompLoadStore.cpp | 9 +- 5 files changed, 319 insertions(+), 9 deletions(-) diff --git a/Common/Arm64Emitter.h b/Common/Arm64Emitter.h index 36e969dd2b..6dbfa3deed 100644 --- a/Common/Arm64Emitter.h +++ b/Common/Arm64Emitter.h @@ -290,6 +290,23 @@ public: } m_shifttype = ST_LSL; } + ArithOption(ARM64Reg Rd, bool index, bool signExtend) { + if (index) + m_shift = 4; + else + m_shift = 0; + + m_destReg = Rd; + m_type = TYPE_EXTENDEDREG; + if (Is64Bit(Rd)) { + m_width = WIDTH_64BIT; + m_extend = EXTEND_UXTX; + } else { + m_width = WIDTH_32BIT; + m_extend = signExtend ? EXTEND_SXTW : EXTEND_UXTW; + } + m_shifttype = ST_LSL; + } ArithOption(ARM64Reg Rd, ShiftType shift_type, u32 shift) { m_destReg = Rd; diff --git a/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp b/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp index 29167b7dd8..42a966d437 100644 --- a/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp +++ b/Core/MIPS/ARM64/Arm64IRCompLoadStore.cpp @@ -38,20 +38,173 @@ namespace MIPSComp { using namespace Arm64Gen; using namespace Arm64IRJitConstants; +static int IROpToByteWidth(IROp op) { + switch (op) { + case IROp::Load8: + case IROp::Load8Ext: + case IROp::Store8: + return 1; + + case IROp::Load16: + case IROp::Load16Ext: + case IROp::Store16: + return 2; + + case IROp::Load32: + case IROp::Load32Linked: + case IROp::Load32Left: + case IROp::Load32Right: + case IROp::LoadFloat: + case IROp::Store32: + case IROp::Store32Conditional: + case IROp::Store32Left: + case IROp::Store32Right: + case IROp::StoreFloat: + return 4; + + case IROp::LoadVec4: + case IROp::StoreVec4: + return 16; + + default: + _assert_msg_(false, "Unexpected op: %s", GetIRMeta(op) ? GetIRMeta(op)->name : "?"); + return -1; + } +} + +Arm64JitBackend::LoadStoreArg Arm64JitBackend::PrepareSrc1Address(IRInst inst) { + const IRMeta *m = GetIRMeta(inst.op); + + bool src1IsPointer = regs_.IsGPRMappedAsPointer(inst.src1); + bool readsFromSrc1 = inst.src1 == inst.src3 && (m->flags & (IRFLAG_SRC3 | IRFLAG_SRC3DST)) != 0; + // If it's about to be clobbered, don't waste time pointerifying. Use displacement. + bool clobbersSrc1 = !readsFromSrc1 && regs_.IsGPRClobbered(inst.src1); + + int32_t imm = (int32_t)inst.constant; + LoadStoreArg addrArg; + if (inst.src1 == MIPS_REG_ZERO) { + // The constant gets applied later. + addrArg.base = MEMBASEREG; +#ifdef MASKED_PSP_MEMORY + imm &= Memory::MEMVIEW32_MASK; +#endif + } else if (!jo.enablePointerify && readsFromSrc1) { +#ifndef MASKED_PSP_MEMORY + if (imm == 0) { + addrArg.base = MEMBASEREG; + addrArg.regOffset = regs_.MapGPR(inst.src1); + addrArg.useRegisterOffset = true; + addrArg.signExtendRegOffset = false; + } +#endif + + // Since we can't modify src1, let's just use a temp reg while copying. + if (!addrArg.useRegisterOffset) { + ADDI2R(SCRATCH1, regs_.MapGPR(inst.src1), (s64)imm, SCRATCH2); +#ifdef MASKED_PSP_MEMORY + ANDI2R(SCRATCH1, SCRATCH1, Memory::MEMVIEW32_MASK, SCRATCH2); +#endif + + addrArg.base = MEMBASEREG; + addrArg.regOffset = SCRATCH1; + addrArg.useRegisterOffset = true; + addrArg.signExtendRegOffset = false; + } + } else if ((jo.cachePointers && !clobbersSrc1) || src1IsPointer) { + // The offset gets set later. + addrArg.base = regs_.MapGPRAsPointer(inst.src1); + } else { + ADDI2R(SCRATCH1, regs_.MapGPR(inst.src1), (s64)imm, SCRATCH2); +#ifdef MASKED_PSP_MEMORY + ANDI2R(SCRATCH1, SCRATCH1, Memory::MEMVIEW32_MASK, SCRATCH2); +#endif + + addrArg.base = MEMBASEREG; + addrArg.regOffset = SCRATCH1; + addrArg.useRegisterOffset = true; + addrArg.signExtendRegOffset = false; + } + + // That's src1 taken care of, and possibly imm. + // If useRegisterOffset is false, imm still needs to be accounted for. + if (!addrArg.useRegisterOffset && imm != 0) { +#ifdef MASKED_PSP_MEMORY + // In case we have an address + offset reg. + if (imm > 0) + imm &= Memory::MEMVIEW32_MASK; +#endif + + int scale = IROpToByteWidth(inst.op); + if (imm > 0 && (imm & (scale - 1)) == 0 && imm <= 0xFFF * scale) { + // Okay great, use the LDR/STR form. + addrArg.immOffset = imm; + addrArg.useUnscaled = false; + } else if (imm >= -256 && imm < 256) { + // An unscaled offset (LDUR/STUR) should work fine for this range. + addrArg.immOffset = imm; + addrArg.useUnscaled = true; + } else { + // No luck, we'll need to load into a register. + MOVI2R(SCRATCH1, (s64)imm); + addrArg.regOffset = SCRATCH1; + addrArg.useRegisterOffset = true; + addrArg.signExtendRegOffset = true; + } + } + + return addrArg; +} + void Arm64JitBackend::CompIR_CondStore(IRInst inst) { CONDITIONAL_DISABLE; if (inst.op != IROp::Store32Conditional) INVALIDOP; - CompIR_Generic(inst); + regs_.SpillLockGPR(IRREG_LLBIT, inst.src3, inst.src1); + LoadStoreArg addrArg = PrepareSrc1Address(inst); + ARM64Reg valueReg = regs_.MapGPR(inst.src3, MIPSMap::INIT); + + regs_.MapGPR(IRREG_LLBIT, MIPSMap::INIT); + + // TODO: Safe memory? Or enough to have crash handler + validate? + + FixupBranch condFailed = CBZ(regs_.R(IRREG_LLBIT)); + + if (addrArg.useRegisterOffset) { + STR(valueReg, addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + STUR(valueReg, addrArg.base, addrArg.immOffset); + } else { + STR(INDEX_UNSIGNED, valueReg, addrArg.base, addrArg.immOffset); + } + + if (inst.dest != MIPS_REG_ZERO) { + MOVI2R(regs_.R(inst.dest), 1); + FixupBranch finish = B(); + + SetJumpTarget(condFailed); + MOVI2R(regs_.R(inst.dest), 0); + SetJumpTarget(finish); + } else { + SetJumpTarget(condFailed); + } } void Arm64JitBackend::CompIR_FLoad(IRInst inst) { CONDITIONAL_DISABLE; + LoadStoreArg addrArg = PrepareSrc1Address(inst); + switch (inst.op) { case IROp::LoadFloat: - CompIR_Generic(inst); + regs_.MapFPR(inst.dest, MIPSMap::NOINIT); + if (addrArg.useRegisterOffset) { + fp_.LDR(32, regs_.F(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + fp_.LDUR(32, regs_.F(inst.dest), addrArg.base, addrArg.immOffset); + } else { + fp_.LDR(32, INDEX_UNSIGNED, regs_.F(inst.dest), addrArg.base, addrArg.immOffset); + } break; default: @@ -63,9 +216,18 @@ void Arm64JitBackend::CompIR_FLoad(IRInst inst) { void Arm64JitBackend::CompIR_FStore(IRInst inst) { CONDITIONAL_DISABLE; + LoadStoreArg addrArg = PrepareSrc1Address(inst); + switch (inst.op) { case IROp::StoreFloat: - CompIR_Generic(inst); + regs_.MapFPR(inst.src3); + if (addrArg.useRegisterOffset) { + fp_.STR(32, regs_.F(inst.src3), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + fp_.STUR(32, regs_.F(inst.src3), addrArg.base, addrArg.immOffset); + } else { + fp_.STR(32, INDEX_UNSIGNED, regs_.F(inst.src3), addrArg.base, addrArg.immOffset); + } break; default: @@ -77,14 +239,75 @@ void Arm64JitBackend::CompIR_FStore(IRInst inst) { void Arm64JitBackend::CompIR_Load(IRInst inst) { CONDITIONAL_DISABLE; + regs_.SpillLockGPR(inst.dest, inst.src1); + LoadStoreArg addrArg = PrepareSrc1Address(inst); + // With NOINIT, MapReg won't subtract MEMBASEREG even if dest == src1. + regs_.MapGPR(inst.dest, MIPSMap::NOINIT); + + // TODO: Safe memory? Or enough to have crash handler + validate? + switch (inst.op) { case IROp::Load8: + if (addrArg.useRegisterOffset) { + LDRB(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDURB(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDRB(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + break; + case IROp::Load8Ext: + if (addrArg.useRegisterOffset) { + LDRSB(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDURSB(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDRSB(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + break; + case IROp::Load16: + if (addrArg.useRegisterOffset) { + LDRH(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDURH(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDRH(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + break; + case IROp::Load16Ext: + if (addrArg.useRegisterOffset) { + LDRSH(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDURSH(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDRSH(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + break; + case IROp::Load32: + if (addrArg.useRegisterOffset) { + LDR(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDUR(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDR(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + break; + case IROp::Load32Linked: - CompIR_Generic(inst); + if (inst.dest != MIPS_REG_ZERO) { + if (addrArg.useRegisterOffset) { + LDR(regs_.R(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + LDUR(regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } else { + LDR(INDEX_UNSIGNED, regs_.R(inst.dest), addrArg.base, addrArg.immOffset); + } + } + regs_.SetGPRImm(IRREG_LLBIT, 1); break; default: @@ -112,11 +335,44 @@ void Arm64JitBackend::CompIR_LoadShift(IRInst inst) { void Arm64JitBackend::CompIR_Store(IRInst inst) { CONDITIONAL_DISABLE; + regs_.SpillLockGPR(inst.src3, inst.src1); + LoadStoreArg addrArg = PrepareSrc1Address(inst); + + ARM64Reg valueReg = regs_.TryMapTempImm(inst.src3); + if (valueReg == INVALID_REG) + valueReg = regs_.MapGPR(inst.src3); + + // TODO: Safe memory? Or enough to have crash handler + validate? + switch (inst.op) { case IROp::Store8: + if (addrArg.useRegisterOffset) { + STRB(valueReg, addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + STURB(valueReg, addrArg.base, addrArg.immOffset); + } else { + STRB(INDEX_UNSIGNED, valueReg, addrArg.base, addrArg.immOffset); + } + break; + case IROp::Store16: + if (addrArg.useRegisterOffset) { + STRH(valueReg, addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + STURH(valueReg, addrArg.base, addrArg.immOffset); + } else { + STRH(INDEX_UNSIGNED, valueReg, addrArg.base, addrArg.immOffset); + } + break; + case IROp::Store32: - CompIR_Generic(inst); + if (addrArg.useRegisterOffset) { + STR(valueReg, addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + STUR(valueReg, addrArg.base, addrArg.immOffset); + } else { + STR(INDEX_UNSIGNED, valueReg, addrArg.base, addrArg.immOffset); + } break; default: @@ -144,9 +400,18 @@ void Arm64JitBackend::CompIR_StoreShift(IRInst inst) { void Arm64JitBackend::CompIR_VecLoad(IRInst inst) { CONDITIONAL_DISABLE; + LoadStoreArg addrArg = PrepareSrc1Address(inst); + switch (inst.op) { case IROp::LoadVec4: - CompIR_Generic(inst); + regs_.MapVec4(inst.dest, MIPSMap::NOINIT); + if (addrArg.useRegisterOffset) { + fp_.LDR(128, regs_.FQ(inst.dest), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + fp_.LDUR(128, regs_.FQ(inst.dest), addrArg.base, addrArg.immOffset); + } else { + fp_.LDR(128, INDEX_UNSIGNED, regs_.FQ(inst.dest), addrArg.base, addrArg.immOffset); + } break; default: @@ -158,9 +423,18 @@ void Arm64JitBackend::CompIR_VecLoad(IRInst inst) { void Arm64JitBackend::CompIR_VecStore(IRInst inst) { CONDITIONAL_DISABLE; + LoadStoreArg addrArg = PrepareSrc1Address(inst); + switch (inst.op) { case IROp::StoreVec4: - CompIR_Generic(inst); + regs_.MapVec4(inst.src3); + if (addrArg.useRegisterOffset) { + fp_.STR(128, regs_.FQ(inst.src3), addrArg.base, ArithOption(addrArg.regOffset, false, addrArg.signExtendRegOffset)); + } else if (addrArg.useUnscaled) { + fp_.STUR(128, regs_.FQ(inst.src3), addrArg.base, addrArg.immOffset); + } else { + fp_.STR(128, INDEX_UNSIGNED, regs_.FQ(inst.src3), addrArg.base, addrArg.immOffset); + } break; default: diff --git a/Core/MIPS/ARM64/Arm64IRJit.h b/Core/MIPS/ARM64/Arm64IRJit.h index fa8bfd89f2..fa2428504c 100644 --- a/Core/MIPS/ARM64/Arm64IRJit.h +++ b/Core/MIPS/ARM64/Arm64IRJit.h @@ -110,6 +110,16 @@ private: void CompIR_VecStore(IRInst inst) override; void CompIR_ValidateAddress(IRInst inst) override; + struct LoadStoreArg { + Arm64Gen::ARM64Reg base = Arm64Gen::INVALID_REG; + Arm64Gen::ARM64Reg regOffset = Arm64Gen::INVALID_REG; + int immOffset = 0; + bool useUnscaled = false; + bool useRegisterOffset = false; + bool signExtendRegOffset = false; + }; + LoadStoreArg PrepareSrc1Address(IRInst inst); + JitOptions &jo; Arm64IRRegCache regs_; Arm64Gen::ARM64FloatEmitter fp_; diff --git a/Core/MIPS/RiscV/RiscVCompLoadStore.cpp b/Core/MIPS/RiscV/RiscVCompLoadStore.cpp index 08f5cb88e2..80b149ca02 100644 --- a/Core/MIPS/RiscV/RiscVCompLoadStore.cpp +++ b/Core/MIPS/RiscV/RiscVCompLoadStore.cpp @@ -55,6 +55,10 @@ void RiscVJitBackend::SetScratch1ToSrc1Address(IRReg src1) { int32_t RiscVJitBackend::AdjustForAddressOffset(RiscVGen::RiscVReg *reg, int32_t constant, int32_t range) { if (constant < -2048 || constant + range > 2047) { +#ifdef MASKED_PSP_MEMORY + if (constant > 0) + constant &= Memory::MEMVIEW32_MASK; +#endif LI(SCRATCH2, constant); ADD(SCRATCH1, *reg, SCRATCH2); *reg = SCRATCH1; diff --git a/Core/MIPS/x86/X64IRCompLoadStore.cpp b/Core/MIPS/x86/X64IRCompLoadStore.cpp index 14c12c2b8a..d033832bf3 100644 --- a/Core/MIPS/x86/X64IRCompLoadStore.cpp +++ b/Core/MIPS/x86/X64IRCompLoadStore.cpp @@ -45,6 +45,11 @@ Gen::OpArg X64JitBackend::PrepareSrc1Address(IRInst inst) { // If it's about to be clobbered, don't waste time pointerifying. Use displacement. bool clobbersSrc1 = !readsFromSrc1 && regs_.IsGPRClobbered(inst.src1); +#ifdef MASKED_PSP_MEMORY + if (inst.constant > 0) + inst.constant &= Memory::MEMVIEW32_MASK; +#endif + OpArg addrArg; if (inst.src1 == MIPS_REG_ZERO) { #ifdef MASKED_PSP_MEMORY @@ -130,7 +135,7 @@ void X64JitBackend::CompIR_FStore(IRInst inst) { switch (inst.op) { case IROp::StoreFloat: regs_.MapFPR(inst.src3); - MOVSS(addrArg, regs_.FX(inst.dest)); + MOVSS(addrArg, regs_.FX(inst.src3)); break; default: @@ -287,7 +292,7 @@ void X64JitBackend::CompIR_VecStore(IRInst inst) { switch (inst.op) { case IROp::StoreVec4: regs_.MapVec4(inst.src3); - MOVUPS(addrArg, regs_.FX(inst.dest)); + MOVUPS(addrArg, regs_.FX(inst.src3)); break; default: From cd78097e74a9e2db44ae1f374cad6d3007c8444b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Mon, 4 Sep 2023 10:01:07 +0200 Subject: [PATCH 37/40] Allow dismissing notifications by touching/clicking them. Fixes #18040 Might do something more elegant in the future. --- Common/System/OSD.cpp | 7 +++++++ Common/System/OSD.h | 3 +++ Common/UI/Screen.cpp | 7 +++++++ UI/OnScreenDisplay.cpp | 17 +++++++++++++++++ UI/OnScreenDisplay.h | 3 +++ 5 files changed, 37 insertions(+) diff --git a/Common/System/OSD.cpp b/Common/System/OSD.cpp index 7c3bb7c7c1..7a896f20a6 100644 --- a/Common/System/OSD.cpp +++ b/Common/System/OSD.cpp @@ -39,6 +39,13 @@ float OnScreenDisplay::SidebarAlpha() const { return saturatef(1.0f - ((float)timeSinceNudge - 0.1f) * 4.0f); } +void OnScreenDisplay::DismissEntry(size_t index, double now) { + std::lock_guard guard(mutex_); + if (index < entries_.size() && entries_[index].type != OSDType::ACHIEVEMENT_CHALLENGE_INDICATOR) { + entries_[index].endTime = std::min(now + FadeoutTime(), entries_[index].endTime); + } +} + void OnScreenDisplay::Show(OSDType type, const std::string &text, const std::string &text2, const std::string &icon, float duration_s, const char *id) { // Automatic duration based on type. if (duration_s <= 0.0f) { diff --git a/Common/System/OSD.h b/Common/System/OSD.h index dd288c01a2..4f81e4ad39 100644 --- a/Common/System/OSD.h +++ b/Common/System/OSD.h @@ -87,6 +87,9 @@ public: std::vector Entries(); + // TODO: Use something more stable than the index. + void DismissEntry(size_t index, double now); + static float FadeinTime() { return 0.1f; } static float FadeoutTime() { return 0.25f; } diff --git a/Common/UI/Screen.cpp b/Common/UI/Screen.cpp index 08ce0a31eb..d42eee36af 100644 --- a/Common/UI/Screen.cpp +++ b/Common/UI/Screen.cpp @@ -48,6 +48,9 @@ void ScreenManager::update() { switchToNext(); } + if (overlayScreen_) { + overlayScreen_->update(); + } if (stack_.size()) { stack_.back().screen->update(); } @@ -90,6 +93,10 @@ void ScreenManager::touch(const TouchInput &touch) { layer.screen->UnsyncTouch(screen->transformTouch(touch)); } } else if (!stack_.empty()) { + // Let the overlay know about touch-downs, to be able to dismiss popups. + if (overlayScreen_ && (touch.flags & TOUCH_DOWN)) { + overlayScreen_->UnsyncTouch(overlayScreen_->transformTouch(touch)); + } Screen *screen = stack_.back().screen; stack_.back().screen->UnsyncTouch(screen->transformTouch(touch)); } diff --git a/UI/OnScreenDisplay.cpp b/UI/OnScreenDisplay.cpp index 2258ba6cc4..954392e09c 100644 --- a/UI/OnScreenDisplay.cpp +++ b/UI/OnScreenDisplay.cpp @@ -448,9 +448,19 @@ void OnScreenMessagesView::Draw(UIContext &dc) { } } + // Quick hack for dismissing messages by touch. + for (auto &touch : touches_) { + if (b.Contains(touch.x, touch.y)) { + INFO_LOG(G3D, "Dismissing entry %d (%0.1f %0.1f vs %0.1f %0.1f %0.1f %0.f)", j, touch.x, touch.y, bounds_.x, bounds_.y, bounds_.w, bounds_.h); + g_OSD.DismissEntry(j, now); + } + } + y += (measuredEntry.h + 4.0f) * measuredEntry.alpha; } } + + touches_.clear(); } std::string OnScreenMessagesView::DescribeText() const { @@ -465,6 +475,13 @@ std::string OnScreenMessagesView::DescribeText() const { return ss.str(); } +bool OnScreenMessagesView::Touch(const TouchInput &input) { + if (input.flags & TOUCH_DOWN) { + touches_.push_back(input); + } + return true; +} + void OSDOverlayScreen::CreateViews() { root_ = new UI::AnchorLayout(); root_->SetTag("OSDOverlayScreen"); diff --git a/UI/OnScreenDisplay.h b/UI/OnScreenDisplay.h index 5cde5cf585..480c34780d 100644 --- a/UI/OnScreenDisplay.h +++ b/UI/OnScreenDisplay.h @@ -21,7 +21,10 @@ class OnScreenMessagesView : public UI::InertView { public: OnScreenMessagesView(UI::LayoutParams *layoutParams = nullptr) : UI::InertView(layoutParams) {} void Draw(UIContext &dc) override; + bool Touch(const TouchInput &input) override; std::string DescribeText() const override; +private: + std::vector touches_; }; class OSDOverlayScreen : public UIScreen { From 005b072fdc88716b7135d834ca585a9003d95356 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Mon, 4 Sep 2023 10:54:17 +0200 Subject: [PATCH 38/40] Flip the problem on its head --- UI/OnScreenDisplay.cpp | 28 ++++++++++++++++++---------- UI/OnScreenDisplay.h | 9 ++++++++- 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/UI/OnScreenDisplay.cpp b/UI/OnScreenDisplay.cpp index 954392e09c..15658fbd3b 100644 --- a/UI/OnScreenDisplay.cpp +++ b/UI/OnScreenDisplay.cpp @@ -367,6 +367,8 @@ void OnScreenMessagesView::Draw(UIContext &dc) { edges[(size_t)pos].maxWidth = std::max(edges[(size_t)pos].maxWidth, measuredEntry.w); } + std::vector dismissZones; + // Now, perform layout for all 8 edges. for (size_t i = 0; i < (size_t)ScreenEdgePosition::VALUE_COUNT; i++) { if (edges[i].height == 0.0f) { @@ -448,19 +450,15 @@ void OnScreenMessagesView::Draw(UIContext &dc) { } } - // Quick hack for dismissing messages by touch. - for (auto &touch : touches_) { - if (b.Contains(touch.x, touch.y)) { - INFO_LOG(G3D, "Dismissing entry %d (%0.1f %0.1f vs %0.1f %0.1f %0.1f %0.f)", j, touch.x, touch.y, bounds_.x, bounds_.y, bounds_.w, bounds_.h); - g_OSD.DismissEntry(j, now); - } - } + // Save the location of the popup, for easy dismissal. + dismissZones.push_back(DismissZone{ (int)j, b }); y += (measuredEntry.h + 4.0f) * measuredEntry.alpha; } } - touches_.clear(); + std::lock_guard lock(dismissMutex_); + dismissZones_ = dismissZones; } std::string OnScreenMessagesView::DescribeText() const { @@ -477,9 +475,19 @@ std::string OnScreenMessagesView::DescribeText() const { bool OnScreenMessagesView::Touch(const TouchInput &input) { if (input.flags & TOUCH_DOWN) { - touches_.push_back(input); + bool dismissed = false; + std::lock_guard lock(dismissMutex_); + double now = time_now_d(); + for (auto &zone : dismissZones_) { + if (zone.bounds.Contains(input.x, input.y)) { + g_OSD.DismissEntry(zone.index, now); + dismissed = true; + } + } + return dismissed; + } else { + return false; } - return true; } void OSDOverlayScreen::CreateViews() { diff --git a/UI/OnScreenDisplay.h b/UI/OnScreenDisplay.h index 480c34780d..70de6dcdb4 100644 --- a/UI/OnScreenDisplay.h +++ b/UI/OnScreenDisplay.h @@ -24,7 +24,14 @@ public: bool Touch(const TouchInput &input) override; std::string DescribeText() const override; private: - std::vector touches_; + struct DismissZone { + int index; + Bounds bounds; + }; + + // Argh, would really like to avoid this. + std::mutex dismissMutex_; + std::vector dismissZones_; }; class OSDOverlayScreen : public UIScreen { From 109205a56a365e1834f98b4cb661472f08d0905c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Mon, 4 Sep 2023 10:58:11 +0200 Subject: [PATCH 39/40] Add return value to UnsyncTouch --- Common/UI/Screen.cpp | 9 ++++++--- Common/UI/Screen.h | 4 +++- Common/UI/UIScreen.cpp | 3 ++- Common/UI/UIScreen.h | 2 +- UI/EmuScreen.cpp | 5 +++-- UI/EmuScreen.h | 2 +- 6 files changed, 16 insertions(+), 9 deletions(-) diff --git a/Common/UI/Screen.cpp b/Common/UI/Screen.cpp index d42eee36af..8863a16140 100644 --- a/Common/UI/Screen.cpp +++ b/Common/UI/Screen.cpp @@ -94,11 +94,14 @@ void ScreenManager::touch(const TouchInput &touch) { } } else if (!stack_.empty()) { // Let the overlay know about touch-downs, to be able to dismiss popups. + bool skip = false; if (overlayScreen_ && (touch.flags & TOUCH_DOWN)) { - overlayScreen_->UnsyncTouch(overlayScreen_->transformTouch(touch)); + skip = overlayScreen_->UnsyncTouch(overlayScreen_->transformTouch(touch)); + } + if (!skip) { + Screen *screen = stack_.back().screen; + stack_.back().screen->UnsyncTouch(screen->transformTouch(touch)); } - Screen *screen = stack_.back().screen; - stack_.back().screen->UnsyncTouch(screen->transformTouch(touch)); } } diff --git a/Common/UI/Screen.h b/Common/UI/Screen.h index 4f559f9ed7..217f6d55dc 100644 --- a/Common/UI/Screen.h +++ b/Common/UI/Screen.h @@ -59,7 +59,9 @@ public: virtual void deviceLost() {} virtual void deviceRestored() {} - virtual void UnsyncTouch(const TouchInput &touch) = 0; + // Return value of UnsyncTouch is only used to let the overlay screen block touches. + virtual bool UnsyncTouch(const TouchInput &touch) = 0; + // Return value of UnsyncKey is used to not block certain system keys like volume when unhandled, on Android. virtual bool UnsyncKey(const KeyInput &touch) = 0; virtual void UnsyncAxis(const AxisInput &touch) = 0; diff --git a/Common/UI/UIScreen.cpp b/Common/UI/UIScreen.cpp index 86b7a34c30..6cb3b54d1f 100644 --- a/Common/UI/UIScreen.cpp +++ b/Common/UI/UIScreen.cpp @@ -81,7 +81,7 @@ bool UIScreen::key(const KeyInput &key) { } } -void UIScreen::UnsyncTouch(const TouchInput &touch) { +bool UIScreen::UnsyncTouch(const TouchInput &touch) { if (ClickDebug && root_ && (touch.flags & TOUCH_DOWN)) { INFO_LOG(SYSTEM, "Touch down!"); std::vector views; @@ -96,6 +96,7 @@ void UIScreen::UnsyncTouch(const TouchInput &touch) { ev.type = QueuedEventType::TOUCH; ev.touch = touch; eventQueue_.push_back(ev); + return false; } void UIScreen::UnsyncAxis(const AxisInput &axis) { diff --git a/Common/UI/UIScreen.h b/Common/UI/UIScreen.h index 0a75c06541..e4cf313766 100644 --- a/Common/UI/UIScreen.h +++ b/Common/UI/UIScreen.h @@ -46,7 +46,7 @@ public: virtual bool key(const KeyInput &key); virtual void axis(const AxisInput &axis); - void UnsyncTouch(const TouchInput &touch) override; + bool UnsyncTouch(const TouchInput &touch) override; bool UnsyncKey(const KeyInput &key) override; void UnsyncAxis(const AxisInput &axis) override; diff --git a/UI/EmuScreen.cpp b/UI/EmuScreen.cpp index 231a695142..13ef0d39fd 100644 --- a/UI/EmuScreen.cpp +++ b/UI/EmuScreen.cpp @@ -563,14 +563,14 @@ void EmuScreen::sendMessage(const char *message, const char *value) { } } -void EmuScreen::UnsyncTouch(const TouchInput &touch) { +bool EmuScreen::UnsyncTouch(const TouchInput &touch) { System_Notify(SystemNotification::ACTIVITY); if (chatMenu_ && chatMenu_->GetVisibility() == UI::V_VISIBLE) { // Avoid pressing touch button behind the chat if (chatMenu_->Contains(touch.x, touch.y)) { chatMenu_->Touch(touch); - return; + return true; } else if ((touch.flags & TOUCH_DOWN) != 0) { chatMenu_->Close(); if (chatButton_) @@ -582,6 +582,7 @@ void EmuScreen::UnsyncTouch(const TouchInput &touch) { if (root_) { root_->Touch(touch); } + return true; } void EmuScreen::onVKey(int virtualKeyCode, bool down) { diff --git a/UI/EmuScreen.h b/UI/EmuScreen.h index 6bfafe62e7..3f07f3d789 100644 --- a/UI/EmuScreen.h +++ b/UI/EmuScreen.h @@ -51,7 +51,7 @@ public: // Note: Unlike your average boring UIScreen, here we override the Unsync* functions // to get minimal latency and full control. We forward to UIScreen when needed. - void UnsyncTouch(const TouchInput &touch) override; + bool UnsyncTouch(const TouchInput &touch) override; bool UnsyncKey(const KeyInput &key) override; void UnsyncAxis(const AxisInput &axis) override; From 78c064cc9634f46a96eaa4b7049912221e17502d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Henrik=20Rydg=C3=A5rd?= Date: Mon, 4 Sep 2023 11:04:15 +0200 Subject: [PATCH 40/40] Bypass normal UI messages to avoid slowing down unsynchrononized touch messages. --- UI/OnScreenDisplay.cpp | 52 ++++++++++++++++++++++++++++-------------- UI/OnScreenDisplay.h | 14 ++++++++---- 2 files changed, 45 insertions(+), 21 deletions(-) diff --git a/UI/OnScreenDisplay.cpp b/UI/OnScreenDisplay.cpp index 15658fbd3b..96a53eaee7 100644 --- a/UI/OnScreenDisplay.cpp +++ b/UI/OnScreenDisplay.cpp @@ -367,7 +367,7 @@ void OnScreenMessagesView::Draw(UIContext &dc) { edges[(size_t)pos].maxWidth = std::max(edges[(size_t)pos].maxWidth, measuredEntry.w); } - std::vector dismissZones; + std::vector dismissZones; // Now, perform layout for all 8 edges. for (size_t i = 0; i < (size_t)ScreenEdgePosition::VALUE_COUNT; i++) { @@ -446,19 +446,30 @@ void OnScreenMessagesView::Draw(UIContext &dc) { float alpha = Clamp((float)(entry.endTime - now) * 4.0f, 0.0f, 1.0f); RenderOSDEntry(dc, entry, b, measuredEntry.h1, measuredEntry.align, alpha); + + switch (entry.type) { + case OSDType::MESSAGE_INFO: + case OSDType::MESSAGE_SUCCESS: + case OSDType::MESSAGE_WARNING: + case OSDType::MESSAGE_ERROR: + case OSDType::MESSAGE_ERROR_DUMP: + case OSDType::MESSAGE_FILE_LINK: + case OSDType::ACHIEVEMENT_UNLOCKED: + // Save the location of the popup, for easy dismissal. + dismissZones.push_back(ClickZone{ (int)j, b }); + break; + } break; } } - // Save the location of the popup, for easy dismissal. - dismissZones.push_back(DismissZone{ (int)j, b }); y += (measuredEntry.h + 4.0f) * measuredEntry.alpha; } } - std::lock_guard lock(dismissMutex_); - dismissZones_ = dismissZones; + std::lock_guard lock(clickMutex_); + clickZones_ = dismissZones; } std::string OnScreenMessagesView::DescribeText() const { @@ -473,18 +484,25 @@ std::string OnScreenMessagesView::DescribeText() const { return ss.str(); } -bool OnScreenMessagesView::Touch(const TouchInput &input) { - if (input.flags & TOUCH_DOWN) { - bool dismissed = false; - std::lock_guard lock(dismissMutex_); - double now = time_now_d(); - for (auto &zone : dismissZones_) { - if (zone.bounds.Contains(input.x, input.y)) { - g_OSD.DismissEntry(zone.index, now); - dismissed = true; - } +// Asynchronous! +bool OnScreenMessagesView::Dismiss(float x, float y) { + bool dismissed = false; + std::lock_guard lock(clickMutex_); + double now = time_now_d(); + for (auto &zone : clickZones_) { + if (zone.bounds.Contains(x, y)) { + g_OSD.DismissEntry(zone.index, now); + dismissed = true; } - return dismissed; + } + return dismissed; +} + +bool OSDOverlayScreen::UnsyncTouch(const TouchInput &touch) { + // Don't really need to forward. + // UIScreen::UnsyncTouch(touch); + if ((touch.flags & TOUCH_DOWN) && osmView_) { + return osmView_->Dismiss(touch.x, touch.y); } else { return false; } @@ -493,7 +511,7 @@ bool OnScreenMessagesView::Touch(const TouchInput &input) { void OSDOverlayScreen::CreateViews() { root_ = new UI::AnchorLayout(); root_->SetTag("OSDOverlayScreen"); - root_->Add(new OnScreenMessagesView(new UI::AnchorLayoutParams(0.0f, 0.0f, 0.0f, 0.0f))); + osmView_ = root_->Add(new OnScreenMessagesView(new UI::AnchorLayoutParams(0.0f, 0.0f, 0.0f, 0.0f))); } void OSDOverlayScreen::render() { diff --git a/UI/OnScreenDisplay.h b/UI/OnScreenDisplay.h index 70de6dcdb4..597fa6e5b9 100644 --- a/UI/OnScreenDisplay.h +++ b/UI/OnScreenDisplay.h @@ -21,24 +21,30 @@ class OnScreenMessagesView : public UI::InertView { public: OnScreenMessagesView(UI::LayoutParams *layoutParams = nullptr) : UI::InertView(layoutParams) {} void Draw(UIContext &dc) override; - bool Touch(const TouchInput &input) override; + bool Dismiss(float x, float y); // Not reusing Touch since it's asynchronous. std::string DescribeText() const override; private: - struct DismissZone { + struct ClickZone { int index; Bounds bounds; }; // Argh, would really like to avoid this. - std::mutex dismissMutex_; - std::vector dismissZones_; + std::mutex clickMutex_; + std::vector clickZones_; }; class OSDOverlayScreen : public UIScreen { public: const char *tag() const override { return "OSDOverlayScreen"; } + + bool UnsyncTouch(const TouchInput &touch) override; + void CreateViews() override; void render() override; + +private: + OnScreenMessagesView *osmView_ = nullptr; }; enum class NoticeLevel {