reorganized libc package

src/core/PS4/HLE/LibC.cpp

@@ -4,8 +4,8 @@
 #include <pthread.h>
 
 #include "../Loader/Elf.h"
-#include "Emulator/HLE/Libraries/LibC/libc.h"
-#include "Emulator/HLE/Libraries/LibC/libc_cxa.h"
+#include "core/hle/libraries/libc/libc.h"
+#include "core/hle/libraries/libc/libc_cxa.h"
 #include "ErrorCodes.h"
 #include "Libs.h"
 
@@ -56,36 +56,36 @@ void PS4_SYSV_ABI qsort(void* ptr, size_t count,size_t size, int(PS4_SYSV_ABI* c
 
 void LibC_Register(SymbolsResolver* sym) {
     LIB_FUNCTION("bzQExy189ZI", "libc", 1, "libc", 1, 1, init_env);
-    LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::Cxa::__cxa_guard_acquire);
-    LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::Cxa::__cxa_guard_release);
-    LIB_FUNCTION("2emaaluWzUw", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::Cxa::__cxa_guard_abort);
-    LIB_FUNCTION("DfivPArhucg", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::memcmp);
-    LIB_FUNCTION("Q3VBxCXhUHs", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::memcpy);
-    LIB_FUNCTION("8zTFvBIAIN8", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::memset);
+    LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::Cxa::__cxa_guard_acquire);
+    LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::Cxa::__cxa_guard_release);
+    LIB_FUNCTION("2emaaluWzUw", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::Cxa::__cxa_guard_abort);
+    LIB_FUNCTION("DfivPArhucg", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::memcmp);
+    LIB_FUNCTION("Q3VBxCXhUHs", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::memcpy);
+    LIB_FUNCTION("8zTFvBIAIN8", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::memset);
     LIB_FUNCTION("XKRegsFpEpk", "libc", 1, "libc", 1, 1, catchReturnFromMain);
-    LIB_FUNCTION("uMei1W9uyNo", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::exit);
-    LIB_FUNCTION("8G2LB+A3rzg", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::atexit);
+    LIB_FUNCTION("uMei1W9uyNo", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::exit);
+    LIB_FUNCTION("8G2LB+A3rzg", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::atexit);
     LIB_FUNCTION("-QgqOT5u2Vk", "libc", 1, "libc", 1, 1, _Assert);
-    LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::printf);
-    LIB_FUNCTION("Q2V+iqvjgC0", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::vsnprintf);
+    LIB_FUNCTION("hcuQgD53UxM", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::printf);
+    LIB_FUNCTION("Q2V+iqvjgC0", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::vsnprintf);
     LIB_FUNCTION("YQ0navp+YIc", "libc", 1, "libc", 1, 1, puts);
     LIB_FUNCTION("cpCOXWMgha0", "libc", 1, "libc", 1, 1, rand);
     LIB_FUNCTION("ZtjspkJQ+vw", "libc", 1, "libc", 1, 1, _Fsin);
     LIB_FUNCTION("AEJdIVZTEmo", "libc", 1, "libc", 1, 1, qsort);
-    LIB_FUNCTION("Ovb2dSJOAuE", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::strcmp);
-    LIB_FUNCTION("gQX+4GDQjpM", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::malloc);
-    LIB_FUNCTION("tIhsqj0qsFE", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::free);
-    LIB_FUNCTION("j4ViWNHEgww", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::strlen);
-    LIB_FUNCTION("6sJWiWSRuqk", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::strncpy);
-    LIB_FUNCTION("+P6FRGH4LfA", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::memmove);
-    LIB_FUNCTION("kiZSXIWd9vg", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::strcpy); 
-    LIB_FUNCTION("Ls4tzzhimqQ", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::strcat);
-    LIB_FUNCTION("EH-x713A99c", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::atan2f);
-    LIB_FUNCTION("QI-x0SL8jhw", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::acosf);
-    LIB_FUNCTION("ZE6RNL+eLbk", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::tanf);
-    LIB_FUNCTION("GZWjF-YIFFk", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::asinf);
-    LIB_FUNCTION("9LCjpWyQ5Zc", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::pow);
-    LIB_FUNCTION("cCXjU72Z0Ow", "libc", 1, "libc", 1, 1, Emulator::HLE::Libraries::LibC::_Sin);
+    LIB_FUNCTION("Ovb2dSJOAuE", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::strcmp);
+    LIB_FUNCTION("gQX+4GDQjpM", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::malloc);
+    LIB_FUNCTION("tIhsqj0qsFE", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::free);
+    LIB_FUNCTION("j4ViWNHEgww", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::strlen);
+    LIB_FUNCTION("6sJWiWSRuqk", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::strncpy);
+    LIB_FUNCTION("+P6FRGH4LfA", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::memmove);
+    LIB_FUNCTION("kiZSXIWd9vg", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::strcpy); 
+    LIB_FUNCTION("Ls4tzzhimqQ", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::strcat);
+    LIB_FUNCTION("EH-x713A99c", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::atan2f);
+    LIB_FUNCTION("QI-x0SL8jhw", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::acosf);
+    LIB_FUNCTION("ZE6RNL+eLbk", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::tanf);
+    LIB_FUNCTION("GZWjF-YIFFk", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::asinf);
+    LIB_FUNCTION("9LCjpWyQ5Zc", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::pow);
+    LIB_FUNCTION("cCXjU72Z0Ow", "libc", 1, "libc", 1, 1,Core::Libraries::LibC::_Sin);
 
     LIB_OBJ("P330P3dFF68", "libc", 1, "libc", 1, 1, &HLE::Libs::LibC::g_need_sceLibc);
 

src/core/hle/libraries/libc/libc.cpp

@@ -0,0 +1,63 @@
+#include "libc.h"
+
+#include <debug.h>
+
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+
+namespace Core::Libraries::LibC {
+
+PS4_SYSV_ABI int printf(VA_ARGS) {
+    VA_CTX(ctx);
+    return printf_ctx(&ctx);
+}
+
+int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) { return vsnprintf_ctx(s, n, format, arg); }
+
+PS4_SYSV_ABI void exit(int code) { std::exit(code); }
+
+PS4_SYSV_ABI int atexit(void (*func)()) {
+    int rt = std::atexit(func);
+    if (rt != 0) {
+        BREAKPOINT();
+    }
+    return rt;
+}
+
+int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) { return std::memcmp(s1, s2, n); }
+
+void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) { return std::memcpy(dest, src, n); }
+
+void* PS4_SYSV_ABI memset(void* s, int c, size_t n) { return std::memset(s, c, n); }
+
+void* PS4_SYSV_ABI malloc(size_t size) { return std::malloc(size); }
+
+void PS4_SYSV_ABI free(void* ptr) { std::free(ptr); }
+
+int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) { return std::strcmp(str1, str2); }
+
+size_t PS4_SYSV_ABI strlen(const char* str) { return std::strlen(str); }
+
+char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) { return std::strncpy(dest, src, count); }
+
+void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) { return std::memmove(dest, src, count); }
+
+char* PS4_SYSV_ABI strcpy(char* dest, const char* src) { return std::strcpy(dest, src); }
+
+char* PS4_SYSV_ABI strcat(char* dest, const char* src) { return std::strcat(dest, src); }
+
+// math
+float PS4_SYSV_ABI atan2f(float y, float x) { return std::atan2f(y, x); }
+
+float PS4_SYSV_ABI acosf(float num) { return std::acosf(num); }
+
+float PS4_SYSV_ABI tanf(float num) { return std::tanf(num); }
+
+float PS4_SYSV_ABI asinf(float num) { return std::asinf(num); }
+
+double PS4_SYSV_ABI pow(double base, double exponent) { return std::pow(base, exponent); }
+
+double PS4_SYSV_ABI _Sin(double x) { return std::sin(x); }
+
+};  // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <types.h>
+
+#include "printf.h"
+
+namespace Core::Libraries::LibC {
+
+// HLE functions
+PS4_SYSV_ABI int printf(VA_ARGS);
+int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg);
+PS4_SYSV_ABI void exit(int code);
+PS4_SYSV_ABI int atexit(void (*func)());
+int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n);
+void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n);
+void* PS4_SYSV_ABI memset(void* s, int c, size_t n);
+void* PS4_SYSV_ABI malloc(size_t size);
+void PS4_SYSV_ABI free(void* ptr);
+int PS4_SYSV_ABI strcmp(const char* str1, const char* str2);
+size_t PS4_SYSV_ABI strlen(const char* str);
+char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count);
+void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count);
+char* PS4_SYSV_ABI strcpy(char* destination, const char* source);
+char* PS4_SYSV_ABI strcat(char* dest, const char* src);
+float PS4_SYSV_ABI atan2f(float y, float x);
+float PS4_SYSV_ABI acosf(float num);
+float PS4_SYSV_ABI tanf(float num);
+float PS4_SYSV_ABI asinf(float num);
+double PS4_SYSV_ABI pow(double base, double exponent);
+double PS4_SYSV_ABI _Sin(double x);
+
+}  // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_cxa.cpp

@@ -0,0 +1,148 @@
+#include "libc_cxa.h"
+
+#include "Util/log.h"
+#include "debug.h"
+
+// adapted from https://opensource.apple.com/source/libcppabi/libcppabi-14/src/cxa_guard.cxx.auto.html
+
+namespace Core::Libraries::LibC::Cxa {
+constexpr bool log_file_cxa = true;  // disable it to disable logging
+
+// This file implements the __cxa_guard_* functions as defined at:
+//     http://www.codesourcery.com/public/cxx-abi/abi.html
+//
+// The goal of these functions is to support thread-safe, one-time
+// initialization of function scope variables.  The compiler will generate
+// code like the following:
+//
+//  if ( obj_guard.first_byte == 0 ) {
+//      if ( __cxa_guard_acquire(&obj_guard) ) {
+//        try {
+//          ... initialize the object ...;
+//        }
+//        catch (...) {
+//          __cxa_guard_abort(&obj_guard);
+//          throw;
+//        }
+//        ... queue object destructor with __cxa_atexit() ...;
+//        __cxa_guard_release(&obj_guard);
+//      }
+//   }
+//
+// Notes:
+//   ojb_guard is a 64-bytes in size and statically initialized to zero.
+//
+//   Section 6.7 of the C++ Spec says "If control re-enters the declaration
+//   recursively while the object is being initialized, the behavior is
+//   undefined".  This implementation calls abort().
+//
+
+// Note don't use function local statics to avoid use of cxa functions...
+static pthread_mutex_t __guard_mutex;
+static pthread_once_t __once_control = PTHREAD_ONCE_INIT;
+
+static void makeRecusiveMutex() {
+    pthread_mutexattr_t recursiveMutexAttr;
+    pthread_mutexattr_init(&recursiveMutexAttr);
+    pthread_mutexattr_settype(&recursiveMutexAttr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&__guard_mutex, &recursiveMutexAttr);
+}
+
+__attribute__((noinline)) static pthread_mutex_t* guard_mutex() {
+    pthread_once(&__once_control, &makeRecusiveMutex);
+    return &__guard_mutex;
+}
+
+// helper functions for getting/setting flags in guard_object
+static bool initializerHasRun(u64* guard_object) { return (*((u08*)guard_object) != 0); }
+
+static void setInitializerHasRun(u64* guard_object) { *((u08*)guard_object) = 1; }
+
+static bool inUse(u64* guard_object) { return (((u08*)guard_object)[1] != 0); }
+
+static void setInUse(u64* guard_object) { ((u08*)guard_object)[1] = 1; }
+
+static void setNotInUse(u64* guard_object) { ((u08*)guard_object)[1] = 0; }
+
+//
+// Returns 1 if the caller needs to run the initializer and then either
+// call __cxa_guard_release() or __cxa_guard_abort().  If zero is returned,
+// then the initializer has already been run.  This function blocks
+// if another thread is currently running the initializer.  This function
+// aborts if called again on the same guard object without an intervening
+// call to __cxa_guard_release() or __cxa_guard_abort().
+//
+int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object) {
+    // Double check that the initializer has not already been run
+    if (initializerHasRun(guard_object)) return 0;
+
+    // We now need to acquire a lock that allows only one thread
+    // to run the initializer.  If a different thread calls
+    // __cxa_guard_acquire() with the same guard object, we want
+    // that thread to block until this thread is done running the
+    // initializer and calls __cxa_guard_release().  But if the same
+    // thread calls __cxa_guard_acquire() with the same guard object,
+    // we want to abort.
+    // To implement this we have one global pthread recursive mutex
+    // shared by all guard objects, but only one at a time.
+
+    int result = ::pthread_mutex_lock(guard_mutex());
+    if (result != 0) {
+        LOG_TRACE_IF(log_file_cxa, "__cxa_guard_acquire(): pthread_mutex_lock failed with {}\n", result);
+    }
+    // At this point all other threads will block in __cxa_guard_acquire()
+
+    // Check if another thread has completed initializer run
+    if (initializerHasRun(guard_object)) {
+        int result = ::pthread_mutex_unlock(guard_mutex());
+        if (result != 0) {
+            LOG_TRACE_IF(log_file_cxa, "__cxa_guard_acquire(): pthread_mutex_unlock failed with {}\n", result);
+        }
+        return 0;
+    }
+
+    // The pthread mutex is recursive to allow other lazy initialized
+    // function locals to be evaluated during evaluation of this one.
+    // But if the same thread can call __cxa_guard_acquire() on the
+    // *same* guard object again, we call abort();
+    if (inUse(guard_object)) {
+        LOG_TRACE_IF(log_file_cxa, "__cxa_guard_acquire(): initializer for function local static variable called enclosing function\n");
+    }
+
+    // mark this guard object as being in use
+    setInUse(guard_object);
+
+    // return non-zero to tell caller to run initializer
+    return 1;
+}
+
+//
+// Sets the first byte of the guard_object to a non-zero value.
+// Releases any locks acquired by __cxa_guard_acquire().
+//
+void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object) {
+    // first mark initalizer as having been run, so
+    // other threads won't try to re-run it.
+    setInitializerHasRun(guard_object);
+
+    // release global mutex
+    int result = ::pthread_mutex_unlock(guard_mutex());
+    if (result != 0) {
+        LOG_TRACE_IF(log_file_cxa, "__cxa_guard_acquire(): pthread_mutex_unlock failed with {}\n", result);
+    }
+}
+
+//
+// Releases any locks acquired by __cxa_guard_acquire().
+//
+void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object) {
+    int result = ::pthread_mutex_unlock(guard_mutex());
+    if (result != 0) {
+        LOG_TRACE_IF(log_file_cxa, "__cxa_guard_abort(): pthread_mutex_unlock failed with {}\n", result);
+    }
+
+    // now reset state, so possible to try to initialize again
+    setNotInUse(guard_object);
+}
+
+}  // namespace Core::Libraries::LibC::Cxa

src/core/hle/libraries/libc/libc_cxa.h

@@ -0,0 +1,11 @@
+#pragma once
+#define _TIMESPEC_DEFINED
+
+#include <pthread.h>
+#include <types.h>
+
+namespace Core::Libraries::LibC::Cxa {
+int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object);
+void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object);
+void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object);
+}  // namespace Core::Libraries::LibC::Cxa

src/core/hle/libraries/libc/printf.h

@@ -0,0 +1,703 @@
+///////////////////////////////////////////////////////////////////////////////
+// \author (c) Marco Paland (info@paland.com)
+//             2014-2018, PALANDesign Hannover, Germany
+//
+// \license The MIT License (MIT)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+// \brief Tiny printf, sprintf and snprintf implementation, optimized for speed on
+//        embedded systems with a very limited resources.
+//        Use this instead of bloated standard/newlib printf.
+//        These routines are thread safe and reentrant!
+//
+///////////////////////////////////////////////////////////////////////////////
+// Vita3K emulator project
+// Copyright (C) 2023 Vita3K team
+//
+// 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; either version 2 of the License, or
+// (at your option) any later version.
+//
+// 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 for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, write to the Free Software Foundation, Inc.,
+// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+// copied from Vita3k project at 6/10/2023 (latest update 30/06/2023)
+// modifications for adapting va_args parameters
+
+#pragma once
+
+#include <stdio.h>
+
+#include <cstdarg>
+#include <cstdbool>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "va_ctx.h"
+
+namespace Core::Libraries::LibC {
+// ntoa conversion buffer size, this must be big enough to hold
+// one converted numeric number including padded zeros (dynamically created on stack)
+// 32 byte is a good default
+#define PRINTF_NTOA_BUFFER_SIZE 32U
+
+// ftoa conversion buffer size, this must be big enough to hold
+// one converted float number including padded zeros (dynamically created on stack)
+// 32 byte is a good default
+#define PRINTF_FTOA_BUFFER_SIZE 32U
+
+// define this to support floating point (%f)
+#define PRINTF_SUPPORT_FLOAT
+
+// define this to support long long types (%llu or %p)
+#define PRINTF_SUPPORT_LONG_LONG
+
+// define this to support the ptrdiff_t type (%t)
+// ptrdiff_t is normally defined in <stddef.h> as long or long long type
+#define PRINTF_SUPPORT_PTRDIFF_T
+
+///////////////////////////////////////////////////////////////////////////////
+
+// internal flag definitions
+#define FLAGS_ZEROPAD (1U << 0U)
+#define FLAGS_LEFT (1U << 1U)
+#define FLAGS_PLUS (1U << 2U)
+#define FLAGS_SPACE (1U << 3U)
+#define FLAGS_HASH (1U << 4U)
+#define FLAGS_UPPERCASE (1U << 5U)
+#define FLAGS_CHAR (1U << 6U)
+#define FLAGS_SHORT (1U << 7U)
+#define FLAGS_LONG (1U << 8U)
+#define FLAGS_LONG_LONG (1U << 9U)
+#define FLAGS_PRECISION (1U << 10U)
+#define FLAGS_WIDTH (1U << 11U)
+
+// output function type
+typedef void (*out_fct_type)(char character, void* buffer, size_t idx, size_t maxlen);
+
+// wrapper (used as buffer) for output function type
+typedef struct {
+    void (*fct)(char character, void* arg);
+    void* arg;
+} out_fct_wrap_type;
+
+// internal buffer output
+static inline void _out_buffer(char character, void* buffer, size_t idx, size_t maxlen) {
+    if (idx < maxlen) {
+        ((char*)buffer)[idx] = character;
+    }
+}
+
+// internal null output
+static inline void _out_null(char character, void* buffer, size_t idx, size_t maxlen) {
+    (void)character;
+    (void)buffer;
+    (void)idx;
+    (void)maxlen;
+}
+
+// internal output function wrapper
+static inline void _out_fct(char character, void* buffer, size_t idx, size_t maxlen) {
+    (void)idx;
+    (void)maxlen;
+    // buffer is the output fct pointer
+    ((out_fct_wrap_type*)buffer)->fct(character, ((out_fct_wrap_type*)buffer)->arg);
+}
+
+// internal strlen
+// \return The length of the string (excluding the terminating 0)
+static inline unsigned int _strlen(const char* str) {
+    const char* s;
+    for (s = str; *s; ++s)
+        ;
+    return (unsigned int)(s - str);
+}
+
+// internal test if char is a digit (0-9)
+// \return true if char is a digit
+static inline bool _is_digit(char ch) { return (ch >= '0') && (ch <= '9'); }
+
+// internal ASCII string to unsigned int conversion
+static inline unsigned int _atoi(const char** str) {
+    unsigned int i = 0U;
+    while (_is_digit(**str)) {
+        i = i * 10U + (unsigned int)(*((*str)++) - '0');
+    }
+    return i;
+}
+
+// internal itoa format
+static inline size_t _ntoa_format(out_fct_type out, char* buffer, size_t idx, size_t maxlen, char* buf, size_t len, bool negative, unsigned int base,
+                                  unsigned int prec, unsigned int width, unsigned int flags) {
+    const size_t start_idx = idx;
+
+    // pad leading zeros
+    while (!(flags & FLAGS_LEFT) && (len < prec) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+        buf[len++] = '0';
+    }
+    while (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+        buf[len++] = '0';
+    }
+
+    // handle hash
+    if (flags & FLAGS_HASH) {
+        if (((len == prec) || (len == width)) && (len > 0U)) {
+            len--;
+            if ((base == 16U) && (len > 0U)) {
+                len--;
+            }
+        }
+        if ((base == 16U) && !(flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = 'x';
+        }
+        if ((base == 16U) && (flags & FLAGS_UPPERCASE) && (len < PRINTF_NTOA_BUFFER_SIZE)) {
+            buf[len++] = 'X';
+        }
+        if (len < PRINTF_NTOA_BUFFER_SIZE) {
+            buf[len++] = '0';
+        }
+    }
+
+    // handle sign
+    if ((len == width) && (negative || (flags & FLAGS_PLUS) || (flags & FLAGS_SPACE))) {
+        len--;
+    }
+    if (len < PRINTF_NTOA_BUFFER_SIZE) {
+        if (negative) {
+            buf[len++] = '-';
+        } else if (flags & FLAGS_PLUS) {
+            buf[len++] = '+';  // ignore the space if the '+' exists
+        } else if (flags & FLAGS_SPACE) {
+            buf[len++] = ' ';
+        }
+    }
+
+    // pad spaces up to given width
+    if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+        for (size_t i = len; i < width; i++) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    // reverse string
+    for (size_t i = 0U; i < len; i++) {
+        out(buf[len - i - 1U], buffer, idx++, maxlen);
+    }
+
+    // append pad spaces up to given width
+    if (flags & FLAGS_LEFT) {
+        while (idx - start_idx < width) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    return idx;
+}
+
+// internal itoa for 'long' type
+static inline size_t _ntoa_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long value, bool negative, unsigned long base,
+                                unsigned int prec, unsigned int width, unsigned int flags) {
+    char buf[PRINTF_NTOA_BUFFER_SIZE];
+    size_t len = 0U;
+
+    // write if precision != 0 and value is != 0
+    if (!(flags & FLAGS_PRECISION) || value) {
+        do {
+            const char digit = (char)(value % base);
+            buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+            value /= base;
+        } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+    }
+
+    return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+
+// internal itoa for 'long long' type
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+static inline size_t _ntoa_long_long(out_fct_type out, char* buffer, size_t idx, size_t maxlen, unsigned long long value, bool negative,
+                                     unsigned long long base, unsigned int prec, unsigned int width, unsigned int flags) {
+    char buf[PRINTF_NTOA_BUFFER_SIZE];
+    size_t len = 0U;
+
+    // write if precision != 0 and value is != 0
+    if (!(flags & FLAGS_PRECISION) || value) {
+        do {
+            const char digit = (char)(value % base);
+            buf[len++] = digit < 10 ? '0' + digit : (flags & FLAGS_UPPERCASE ? 'A' : 'a') + digit - 10;
+            value /= base;
+        } while (value && (len < PRINTF_NTOA_BUFFER_SIZE));
+    }
+
+    return _ntoa_format(out, buffer, idx, maxlen, buf, len, negative, (unsigned int)base, prec, width, flags);
+}
+#endif  // PRINTF_SUPPORT_LONG_LONG
+
+#if defined(PRINTF_SUPPORT_FLOAT)
+static inline size_t _ftoa(out_fct_type out, char* buffer, size_t idx, size_t maxlen, double value, unsigned int prec, unsigned int width,
+                           unsigned int flags) {
+    char buf[PRINTF_FTOA_BUFFER_SIZE];
+    size_t len = 0U;
+    double diff = 0.0;
+
+    // if input is larger than thres_max, revert to exponential
+    const double thres_max = (double)0x7FFFFFFF;
+
+    // powers of 10
+    static const double pow10[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
+
+    // test for negative
+    bool negative = false;
+    if (value < 0) {
+        negative = true;
+        value = 0 - value;
+    }
+
+    // set default precision to 6, if not set explicitly
+    if (!(flags & FLAGS_PRECISION)) {
+        prec = 6U;
+    }
+    // limit precision to 9, cause a prec >= 10 can lead to overflow errors
+    while ((len < PRINTF_FTOA_BUFFER_SIZE) && (prec > 9U)) {
+        buf[len++] = '0';
+        prec--;
+    }
+
+    int whole = (int)value;
+    double tmp = (value - whole) * pow10[prec];
+    unsigned long frac = (unsigned long)tmp;
+    diff = tmp - frac;
+
+    if (diff > 0.5) {
+        ++frac;
+        // handle rollover, e.g. case 0.99 with prec 1 is 1.0
+        if (frac >= pow10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    } else if ((diff == 0.5) && ((frac == 0U) || (frac & 1U))) {
+        // if halfway, round up if odd, OR if last digit is 0
+        ++frac;
+    }
+
+    // TBD: for very large numbers switch back to native sprintf for exponentials. Anyone want to write code to replace this?
+    // Normal printf behavior is to print EVERY whole number digit which can be 100s of characters overflowing your buffers == bad
+    if (value > thres_max) {
+        return 0U;
+    }
+
+    if (prec == 0U) {
+        diff = value - (double)whole;
+        if (diff > 0.5) {
+            // greater than 0.5, round up, e.g. 1.6 -> 2
+            ++whole;
+        } else if ((diff == 0.5) && (whole & 1)) {
+            // exactly 0.5 and ODD, then round up
+            // 1.5 -> 2, but 2.5 -> 2
+            ++whole;
+        }
+    } else {
+        unsigned int count = prec;
+        // now do fractional part, as an unsigned number
+        while (len < PRINTF_FTOA_BUFFER_SIZE) {
+            --count;
+            buf[len++] = (char)(48U + (frac % 10U));
+            if (!(frac /= 10U)) {
+                break;
+            }
+        }
+        // add extra 0s
+        while ((len < PRINTF_FTOA_BUFFER_SIZE) && (count-- > 0U)) {
+            buf[len++] = '0';
+        }
+        if (len < PRINTF_FTOA_BUFFER_SIZE) {
+            // add decimal
+            buf[len++] = '.';
+        }
+    }
+
+    // do whole part, number is reversed
+    while (len < PRINTF_FTOA_BUFFER_SIZE) {
+        buf[len++] = (char)(48 + (whole % 10));
+        if (!(whole /= 10)) {
+            break;
+        }
+    }
+
+    // pad leading zeros
+    while (!(flags & FLAGS_LEFT) && (flags & FLAGS_ZEROPAD) && (len < width) && (len < PRINTF_FTOA_BUFFER_SIZE)) {
+        buf[len++] = '0';
+    }
+
+    // handle sign
+    if ((len == width) && (negative || (flags & FLAGS_PLUS) || (flags & FLAGS_SPACE))) {
+        len--;
+    }
+    if (len < PRINTF_FTOA_BUFFER_SIZE) {
+        if (negative) {
+            buf[len++] = '-';
+        } else if (flags & FLAGS_PLUS) {
+            buf[len++] = '+';  // ignore the space if the '+' exists
+        } else if (flags & FLAGS_SPACE) {
+            buf[len++] = ' ';
+        }
+    }
+
+    // pad spaces up to given width
+    if (!(flags & FLAGS_LEFT) && !(flags & FLAGS_ZEROPAD)) {
+        for (size_t i = len; i < width; i++) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    // reverse string
+    for (size_t i = 0U; i < len; i++) {
+        out(buf[len - i - 1U], buffer, idx++, maxlen);
+    }
+
+    // append pad spaces up to given width
+    if (flags & FLAGS_LEFT) {
+        while (idx < width) {
+            out(' ', buffer, idx++, maxlen);
+        }
+    }
+
+    return idx;
+}
+#endif  // PRINTF_SUPPORT_FLOAT
+
+// internal vsnprintf
+static inline int _vsnprintf(out_fct_type out, char* buffer, const char* format, VaList* va_list) {
+    unsigned int flags, width, precision, n;
+    size_t idx = 0U;
+    auto maxlen = static_cast<size_t>(-1);
+
+    if (!buffer) {
+        // use null output function
+        out = _out_null;
+    }
+
+    while (*format) {
+        // format specifier?  %[flags][width][.precision][length]
+        if (*format != '%') {
+            // no
+            out(*format, buffer, idx++, maxlen);
+            format++;
+            continue;
+        } else {
+            // yes, evaluate it
+            format++;
+        }
+
+        // evaluate flags
+        flags = 0U;
+        do {
+            switch (*format) {
+                case '0':
+                    flags |= FLAGS_ZEROPAD;
+                    format++;
+                    n = 1U;
+                    break;
+                case '-':
+                    flags |= FLAGS_LEFT;
+                    format++;
+                    n = 1U;
+                    break;
+                case '+':
+                    flags |= FLAGS_PLUS;
+                    format++;
+                    n = 1U;
+                    break;
+                case ' ':
+                    flags |= FLAGS_SPACE;
+                    format++;
+                    n = 1U;
+                    break;
+                case '#':
+                    flags |= FLAGS_HASH;
+                    format++;
+                    n = 1U;
+                    break;
+                default: n = 0U; break;
+            }
+        } while (n);
+
+        // evaluate width field
+        width = 0U;
+        if (_is_digit(*format)) {
+            width = _atoi(&format);
+        } else if (*format == '*') {
+            const int w = vaArgInteger(va_list);  // const int w = va.next<int>(cpu, mem);
+
+            if (w < 0) {
+                flags |= FLAGS_LEFT;  // reverse padding
+                width = (unsigned int)-w;
+            } else {
+                width = (unsigned int)w;
+            }
+            format++;
+        }
+
+        // evaluate precision field
+        precision = 0U;
+        if (*format == '.') {
+            flags |= FLAGS_PRECISION;
+            format++;
+            if (_is_digit(*format)) {
+                precision = _atoi(&format);
+            } else if (*format == '*') {
+                precision = vaArgInteger(va_list);  // precision = (unsigned int)va.next<int>(cpu, mem);
+                format++;
+            }
+        }
+
+        // evaluate length field
+        switch (*format) {
+            case 'l':
+                flags |= FLAGS_LONG;
+                format++;
+                if (*format == 'l') {
+                    flags |= FLAGS_LONG_LONG;
+                    format++;
+                }
+                break;
+            case 'h':
+                flags |= FLAGS_SHORT;
+                format++;
+                if (*format == 'h') {
+                    flags |= FLAGS_CHAR;
+                    format++;
+                }
+                break;
+#if defined(PRINTF_SUPPORT_PTRDIFF_T)
+            case 't':
+                flags |= (sizeof(ptrdiff_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+#endif
+            case 'j':
+                flags |= (sizeof(intmax_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+            case 'z':
+                flags |= (sizeof(size_t) == sizeof(long) ? FLAGS_LONG : FLAGS_LONG_LONG);
+                format++;
+                break;
+            default: break;
+        }
+
+        // evaluate specifier
+        switch (*format) {
+            case 'd':
+            case 'i':
+            case 'u':
+            case 'x':
+            case 'X':
+            case 'o':
+            case 'b': {
+                // set the base
+                unsigned int base;
+                if (*format == 'x' || *format == 'X') {
+                    base = 16U;
+                } else if (*format == 'o') {
+                    base = 8U;
+                } else if (*format == 'b') {
+                    base = 2U;
+                    flags &= ~FLAGS_HASH;  // no hash for bin format
+                } else {
+                    base = 10U;
+                    flags &= ~FLAGS_HASH;  // no hash for dec format
+                }
+                // uppercase
+                if (*format == 'X') {
+                    flags |= FLAGS_UPPERCASE;
+                }
+
+                // no plus or space flag for u, x, X, o, b
+                if ((*format != 'i') && (*format != 'd')) {
+                    flags &= ~(FLAGS_PLUS | FLAGS_SPACE);
+                }
+
+                // convert the integer
+                if ((*format == 'i') || (*format == 'd')) {
+                    // signed
+                    if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                        auto value = vaArgLongLong(va_list);  // const long long value = va.next<long long>(cpu, mem);
+                        idx = _ntoa_long_long(out, buffer, idx, maxlen, (unsigned long long)(value > 0 ? value : 0 - value), value < 0, base,
+                                              precision, width, flags);
+#endif
+                    } else if (flags & FLAGS_LONG) {
+                        auto value = vaArgLong(va_list);  // const long value = va.next<long>(cpu, mem);
+                        idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)(value > 0 ? value : 0 - value), value < 0, base, precision, width,
+                                         flags);
+                    } else {
+                        // const int value = (flags & FLAGS_CHAR) ? (char)va.next<int>(cpu, mem) : (flags & FLAGS_SHORT) ? (short
+                        // int)va.next<int>(cpu, mem): va.next<int>(cpu, mem);
+                        const int value = (flags & FLAGS_CHAR)    ? static_cast<char>(vaArgInteger(va_list))
+                                          : (flags & FLAGS_SHORT) ? static_cast<int16_t>(vaArgInteger(va_list))
+                                                                  : vaArgInteger(va_list);
+                        idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned int)(value > 0 ? value : 0 - value), value < 0, base, precision, width,
+                                         flags);
+                    }
+                } else {
+                    // unsigned
+                    if (flags & FLAGS_LONG_LONG) {
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                        // idx = _ntoa_long_long(out, buffer, idx, maxlen, va.next<unsigned long long>(cpu, mem), false, base, precision, width,
+                        // flags);
+                        idx =
+                            _ntoa_long_long(out, buffer, idx, maxlen, static_cast<u64>(vaArgLongLong(va_list)), false, base, precision, width, flags);
+#endif
+                    } else if (flags & FLAGS_LONG) {
+                        // idx = _ntoa_long(out, buffer, idx, maxlen, va.next<unsigned long>(cpu, mem), false, base, precision, width, flags);
+                        idx = _ntoa_long(out, buffer, idx, maxlen, static_cast<u32>(vaArgLong(va_list)), false, base, precision, width, flags);
+                    } else {
+                        // const unsigned int value = (flags & FLAGS_CHAR) ? (unsigned char)va.next<unsigned int>(cpu, mem) : (flags & FLAGS_SHORT) ?
+                        //     (unsigned short int)va.next<unsigned int>(cpu, mem) : va.next<unsigned int>(cpu, mem);
+                        const unsigned int value = (flags & FLAGS_CHAR)    ? static_cast<u08>(vaArgInteger(va_list))
+                                                   : (flags & FLAGS_SHORT) ? static_cast<u16>(vaArgInteger(va_list))
+                                                                           : static_cast<u32>(vaArgInteger(va_list));
+                        idx = _ntoa_long(out, buffer, idx, maxlen, value, false, base, precision, width, flags);
+                    }
+                }
+                format++;
+                break;
+            }
+#if defined(PRINTF_SUPPORT_FLOAT)
+            case 'f':
+            case 'F':
+                // idx = _ftoa(out, buffer, idx, maxlen, va.next<double>(cpu, mem), precision, width, flags);
+                idx = _ftoa(out, buffer, idx, maxlen, vaArgDouble(va_list), precision, width, flags);
+                format++;
+                break;
+#endif  // PRINTF_SUPPORT_FLOAT
+            case 'c': {
+                unsigned int l = 1U;
+                // pre padding
+                if (!(flags & FLAGS_LEFT)) {
+                    while (l++ < width) {
+                        out(' ', buffer, idx++, maxlen);
+                    }
+                }
+                // char output
+                // out((char)va.next<int>(cpu, mem), buffer, idx++, maxlen);
+                out(static_cast<char>(vaArgInteger(va_list)), buffer, idx++, maxlen);
+                // post padding
+                if (flags & FLAGS_LEFT) {
+                    while (l++ < width) {
+                        out(' ', buffer, idx++, maxlen);
+                    }
+                }
+                format++;
+                break;
+            }
+
+            case 's': {
+                const char* p = vaArgPtr<const char>(va_list);  // const char *p = va.next<Ptr<char>>(cpu, mem).get(mem);
+                p = p != nullptr ? p : "(null)";
+                unsigned int l = _strlen(p);
+                // pre padding
+                if (flags & FLAGS_PRECISION) {
+                    l = (l < precision ? l : precision);
+                }
+                if (!(flags & FLAGS_LEFT)) {
+                    while (l++ < width) {
+                        out(' ', buffer, idx++, maxlen);
+                    }
+                }
+                // string output
+                while ((*p != 0) && (!(flags & FLAGS_PRECISION) || precision--)) {
+                    out(*(p++), buffer, idx++, maxlen);
+                }
+                // post padding
+                if (flags & FLAGS_LEFT) {
+                    while (l++ < width) {
+                        out(' ', buffer, idx++, maxlen);
+                    }
+                }
+                format++;
+                break;
+            }
+
+            case 'p': {
+                width = sizeof(void*) * 2U;
+                flags |= FLAGS_ZEROPAD | FLAGS_UPPERCASE;
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                const bool is_ll = sizeof(uintptr_t) == sizeof(long long);
+                if (is_ll) {
+                    // idx = _ntoa_long_long(out, buffer, idx, maxlen, (uintptr_t)va.next<Ptr<void>>(cpu, mem).address(), false, 16U, precision,
+                    // width, flags);
+                    idx = _ntoa_long_long(out, buffer, idx, maxlen, reinterpret_cast<uintptr_t>(vaArgPtr<void>(va_list)), false, 16U, precision,
+                                          width, flags);
+                } else {
+#endif
+                    // idx = _ntoa_long(out, buffer, idx, maxlen, (unsigned long)((uintptr_t)va.next<Ptr<void>>(cpu, mem).address()), false, 16U,
+                    // precision, width, flags);
+                    idx = _ntoa_long(out, buffer, idx, maxlen, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(vaArgPtr<void>(va_list))), false,
+                                     16U, precision, width, flags);
+#if defined(PRINTF_SUPPORT_LONG_LONG)
+                }
+#endif
+                format++;
+                break;
+            }
+
+            case '%':
+                out('%', buffer, idx++, maxlen);
+                format++;
+                break;
+
+            default:
+                out(*format, buffer, idx++, maxlen);
+                format++;
+                break;
+        }
+    }
+
+    // termination
+    out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+    // return written chars without terminating \0
+    return (int)idx;
+}
+
+static int printf_ctx(VaCtx* ctx) {
+    const char* format = vaArgPtr<const char>(&ctx->va_list);
+    char buffer[256];
+    int result = _vsnprintf(_out_buffer, buffer, format, &ctx->va_list);
+    printf("%s", buffer);
+    return result;
+}
+
+static int vsnprintf_ctx(char* s, size_t n, const char* format, VaList* arg) {
+    char buffer[n];
+    int result = _vsnprintf(_out_buffer, buffer, format, arg);
+    std::strcpy(s, buffer);
+    return result;
+}
+}  // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/va_ctx.h

@@ -0,0 +1,106 @@
+#include <types.h>
+#include <xmmintrin.h>
+
+#define VA_ARGS                                                                                                                             \
+    uint64_t rdi, uint64_t rsi, uint64_t rdx, uint64_t rcx, uint64_t r8, uint64_t r9, uint64_t overflow_arg_area, __m128 xmm0, __m128 xmm1, \
+        __m128 xmm2, __m128 xmm3, __m128 xmm4, __m128 xmm5, __m128 xmm6, __m128 xmm7, ...
+
+#define VA_CTX(ctx)                                     \
+    alignas(16) VaCtx ctx;                              \
+    (ctx).reg_save_area.gp[0] = rdi;                    \
+    (ctx).reg_save_area.gp[1] = rsi;                    \
+    (ctx).reg_save_area.gp[2] = rdx;                    \
+    (ctx).reg_save_area.gp[3] = rcx;                    \
+    (ctx).reg_save_area.gp[4] = r8;                     \
+    (ctx).reg_save_area.gp[5] = r9;                     \
+    (ctx).reg_save_area.fp[0] = xmm0;                   \
+    (ctx).reg_save_area.fp[1] = xmm1;                   \
+    (ctx).reg_save_area.fp[2] = xmm2;                   \
+    (ctx).reg_save_area.fp[3] = xmm3;                   \
+    (ctx).reg_save_area.fp[4] = xmm4;                   \
+    (ctx).reg_save_area.fp[5] = xmm5;                   \
+    (ctx).reg_save_area.fp[6] = xmm6;                   \
+    (ctx).reg_save_area.fp[7] = xmm7;                   \
+    (ctx).va_list.reg_save_area = &(ctx).reg_save_area; \
+    (ctx).va_list.gp_offset = offsetof(VaRegSave, gp);  \
+    (ctx).va_list.fp_offset = offsetof(VaRegSave, fp);  \
+    (ctx).va_list.overflow_arg_area = &overflow_arg_area;
+
+namespace Core::Libraries::LibC {
+
+// https://stackoverflow.com/questions/4958384/what-is-the-format-of-the-x86-64-va-list-structure
+
+struct VaList {
+    u32 gp_offset;
+    u32 fp_offset;
+    void* overflow_arg_area;
+    void* reg_save_area;
+};
+
+struct VaRegSave {
+    u64 gp[6];
+    __m128 fp[8];
+};
+
+struct VaCtx {
+    VaRegSave reg_save_area;
+    VaList va_list;
+};
+
+template <class T, uint32_t Size>
+T vaArgRegSaveAreaGp(VaList* l) {
+    auto* addr = reinterpret_cast<T*>(static_cast<u08*>(l->reg_save_area) + l->gp_offset);
+    l->gp_offset += Size;
+    return *addr;
+}
+template <class T, u64 Align, u64 Size>
+T vaArgOverflowArgArea(VaList* l) {
+    auto ptr = ((reinterpret_cast<u64>(l->overflow_arg_area) + (Align - 1)) & ~(Align - 1));
+    auto* addr = reinterpret_cast<T*>(ptr);
+    l->overflow_arg_area = reinterpret_cast<void*>(ptr + Size);
+    return *addr;
+}
+
+template <class T, uint32_t Size>
+T vaArgRegSaveAreaFp(VaList* l) {
+    auto* addr = reinterpret_cast<T*>(static_cast<u08*>(l->reg_save_area) + l->fp_offset);
+    l->fp_offset += Size;
+    return *addr;
+}
+
+inline int vaArgInteger(VaList* l) {
+    if (l->gp_offset <= 40) {
+        return vaArgRegSaveAreaGp<int, 8>(l);
+    }
+    return vaArgOverflowArgArea<int, 1, 8>(l);
+}
+
+inline long long vaArgLongLong(VaList* l) {
+    if (l->gp_offset <= 40) {
+        return vaArgRegSaveAreaGp<long long, 8>(l);
+    }
+    return vaArgOverflowArgArea<long long, 1, 8>(l);
+}
+inline long vaArgLong(VaList* l) {
+    if (l->gp_offset <= 40) {
+        return vaArgRegSaveAreaGp<long, 8>(l);
+    }
+    return vaArgOverflowArgArea<long, 1, 8>(l);
+}
+
+inline double vaArgDouble(VaList* l) {
+    if (l->fp_offset <= 160) {
+        return vaArgRegSaveAreaFp<double, 16>(l);
+    }
+    return vaArgOverflowArgArea<double, 1, 8>(l);
+}
+
+template <class T>
+T* vaArgPtr(VaList* l) {
+    if (l->gp_offset <= 40) {
+        return vaArgRegSaveAreaGp<T*, 8>(l);
+    }
+    return vaArgOverflowArgArea<T*, 1, 8>(l);
+}
+
+}  // namespace Core::Libraries::LibC