Merge remote-tracking branch 'upstream/main' into fuckit

# Conflicts:
#	src/mips/tests/Makefile

Author: nicolasnoble

src/core/debug.cc

@@ -247,7 +247,7 @@ void PCSX::Debug::checkBP(uint32_t address, BreakpointType type, uint32_t width,
     auto end = m_breakpoints.end();
     uint32_t normalizedAddress = normalizeAddress(address & ~0xe0000000);
 
-    BreakpointUserListType torun;
+    BreakpointTemporaryListType torun;
     for (auto it = m_breakpoints.find(normalizedAddress, normalizedAddress + width - 1); it != end; it++) {
         if (it->type() != type) continue;
         auto bp = &*it;

src/core/debug.h

@@ -62,11 +62,15 @@ class Debug {
     class Breakpoint;
     typedef Intrusive::Tree<uint32_t, Breakpoint> BreakpointTreeType;
     typedef Intrusive::List<Breakpoint> BreakpointUserListType;
+    struct InternalTemporaryList {};
+    typedef Intrusive::List<Breakpoint, InternalTemporaryList> BreakpointTemporaryListType;
 
     typedef std::function<bool(const Breakpoint*, uint32_t address, unsigned width, const char* cause)>
         BreakpointInvoker;
 
-    class Breakpoint : public BreakpointTreeType::Node, public BreakpointUserListType::Node {
+    class Breakpoint : public BreakpointTreeType::Node,
+                       public BreakpointUserListType::Node,
+                       public BreakpointTemporaryListType::Node {
       public:
         Breakpoint(BreakpointType type, const std::string& source, BreakpointInvoker invoker, uint32_t base,
                    std::string label = "")

src/core/gdb-server.cc

@@ -608,7 +608,7 @@ void PCSX::GdbClient::processCommand() {
                 auto& tree = g_emulator->m_debug->getTree();
                 auto bp = tree.find(addr, Debug::BreakpointTreeType::INTERVAL_SEARCH);
                 while (bp != tree.end()) {
-                    if (bp->type() == type && !bp->Debug::BreakpointUserListType::Node::isLinked()) {
+                    if (bp->type() == type && !m_breakpoints.isLinked(&*bp)) {
                         bp++;
                     } else {
                         g_emulator->m_debug->removeBreakpoint(&*bp);

src/gpu/soft/soft.cc

@@ -3378,7 +3378,7 @@ void PCSX::SoftGPU::SoftRenderer::drawPoly3TD(int16_t x1, int16_t y1, int16_t x2
                     auto dnY = ((posY >> 16) & maskY) + globalTextAddrY + textureWindow.y0;
                     uint32_t color = vram16[upX + (upY << 10)];
                     color <<= 16;
-                    color |= vram[dnX + (dnY << 10)];
+                    color |= vram16[dnX + (dnY << 10)];
                     getTextureTransColShade32Solid(pdest, color);
 
                     posX += difX2;

src/mips/common.mk

@@ -86,7 +86,7 @@ $(BINDIR)$(TARGET).elf: $(OBJS) $(LIBRARIES) $(EXTRA_DEPS)
 ifneq ($(strip $(BINDIR)),)
 	mkdir -p $(BINDIR)
 endif
-	$(CC) -g -o $(BINDIR)$(TARGET).elf $(OBJS) $(LDFLAGS) $(LIBRARIES)
+	$(CC) $(LDFLAGS) -g -o $(BINDIR)$(TARGET).elf $(OBJS) $(LIBRARIES)
 
 $(BINDIR)lib$(TARGET).a: $(OBJS) $(EXTRA_DEPS)
 	$(AR) rcs $(BINDIR)lib$(TARGET).a $(OBJS)

src/mips/common/crt0/README.md

@@ -0,0 +1,12 @@
+# Limited C runtime
+
+This directory contains some limited C runtime features. It will take care of booting the binary, setting up some minimal environment and then call the main function. It also contains some basic implementations of standard C functions which are required by the compiler when doing self-hosted compilation.
+
+## Using very bare C runtime
+The file `crt0.s` is the entry point of the C runtime. It will set up the stack, and call the `main` function. It will not perform any other initialization beyond clearing the BSS section.
+
+## Using C++ runtime
+The file `crt0cxx.s` is the entry point of the C++ runtime. It will set up the stack, and then go to the `cxxglue.c` file for further initialization, which will then call the `main` function. The `cxxglue.c` file also contains the minimal implementation of the C++ runtime that is required by the C++ compiler.
+
+## Memory C runtime functions
+The files `memory-c.c` and `memory-s.s` contain the 4 basic memory functions that are required by the self-hosted C and C++ compilers. These are `memcpy`, `memset`, `memcmp`, and `memmove`. These are implemented in a very basic way, being very small, and are not optimized for speed. They also contain optimized versions of `memcpy` and `memset` for the MIPS architecture, available using the LDFLAGS `-Wl,-wrap,memcpy` and `-Wl,-wrap,memset` toggles. They are somewhat bigger, but much faster. Note that these 4 functions are available directly when writing C or C++ code using the `__builtin_memcpy`, `__builtin_memset`, `__builtin_memcmp` and `__builtin_memmove` functions, with no need to include any header file.

src/mips/common/crt0/cxxglue.c

@@ -25,13 +25,11 @@ SOFTWARE.
 */
 
 /* Properly using C++ on the PSX requires a form of the libstdc++ that's
-typically called "freestanding", which isn't really buildable at the moment.
-See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100057 for details.
-This means however that using a full linux compiler such as the Ubuntu
-mipsel compiler package will bring in a libstdc++ that utilizes all of
-the existing libc. Properly filling in portions of the required ABI, while
-avoiding the bits that won't work can be tricky, but is doable. Using a
-freestanding compiler won't have the libstdc++, and this wouldn't work. */
+typically called "freestanding". While it would contain enough to support
+metaprogramming and other C++ features, it would not contain any of the
+standard library, as the PSX doesn't have an operating system to speak of.
+This code is a minimal implementation of the C++ ABI that's required to
+fill in the gaps that the freestanding libstdc++ would have. */
 
 #include <stdatomic.h>
 #include <stddef.h>
@@ -135,57 +133,6 @@ __attribute__((weak)) void __cxa_atexit(void (*func)(void*), void* arg, void* ds
 // no, we're not going to have shared libraries
 __attribute__((weak)) void* __dso_handle = NULL;
 
-__attribute__((weak)) void* memcpy(void* s1_, const void* s2_, size_t n) {
-    uint8_t* s1 = (uint8_t*)s1_;
-    const uint8_t* s2 = (uint8_t*)s2_;
-    size_t i;
-
-    for (i = 0; i < n; i++) *s1++ = *s2++;
-
-    return s1_;
-}
-
-__attribute__((weak)) void* memmove(void* s1_, const void* s2_, size_t n) {
-    uint8_t* s1 = (uint8_t*)s1_;
-    const uint8_t* s2 = (uint8_t*)s2_;
-    size_t i;
-
-    if (s1 < s2) {
-        for (i = 0; i < n; i++) *s1++ = *s2++;
-    } else if (s1 > s2) {
-        s1 += n;
-        s2 += n;
-        for (i = 0; i < n; i++) *--s1 = *--s2;
-    }
-
-    return s1_;
-}
-
-__attribute__((weak)) int memcmp(const void* s1_, const void* s2_, size_t n) {
-    uint8_t* s1 = (uint8_t*)s1_;
-    const uint8_t* s2 = (uint8_t*)s2_;
-    size_t i;
-
-    for (i = 0; i < n; i++, s1++, s2++) {
-        if (*s1 < *s2) {
-            return -1;
-        } else if (*s1 > *s2) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-
-__attribute__((weak)) void* memset(void* s_, int c, size_t n) {
-    uint8_t* s = (uint8_t*)s_;
-    size_t i;
-
-    for (i = 0; i < n; i++) *s++ = (uint8_t)c;
-
-    return s_;
-}
-
 /* Some helpers to make sure we're not going to be preempted during object creation */
 static inline uint32_t getCop0Status() {
     uint32_t r;

src/mips/common/crt0/memory-c.c

@@ -0,0 +1,90 @@
+/*
+
+MIT License
+
+Copyright (c) 2024 PCSX-Redux authors
+
+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.
+
+*/
+
+#include <stdint.h>
+#include <stddef.h>
+
+// These are the 4 essential functions expected by gcc for a naked build.
+// The implementation of memcpy is in memory-s.s, and the rest are here.
+// The weak attribute is used to allow the user to override these functions
+// with their own implementation if they so desire. The memory-s.s implementation
+// is a simple byte copy, and is not optimized for speed. The file also contains
+// a faster but bigger implementation that can be used instead, called
+// __wrap_memcpy. The user can override memcpy with __wrap_memcpy to use it using
+// the -Wl,--wrap=memcpy switch to the linker using LDFLAGS. The same file also
+// contains a fast implementation of memset, called __wrap_memset, that can be
+// used in the same way.
+
+void* memcpy(void* s1_, const void* s2_, size_t n);
+
+__attribute__((weak)) void* memmove(void* s1_, const void* s2_, size_t n) {
+    uint8_t* s1 = (uint8_t*)s1_;
+    const uint8_t* s2 = (uint8_t*)s2_;
+    size_t i;
+
+    uint8_t* e1 = s1 + n;
+    const uint8_t* e2 = s2 + n;
+
+    if ((s1 <= s2) && (s2 <= e1) || ((s2 <= s1) && (s1 <= e2))) {
+        if (s1 < s2) {
+            for (i = 0; i < n; i++) *s1++ = *s2++;
+        } else if (s1 > s2) {
+            s1 += n;
+            s2 += n;
+            for (i = 0; i < n; i++) *--s1 = *--s2;
+        }
+    } else {
+        return memcpy(s1_, s2_, n);
+    }
+
+    return s1_;
+}
+
+__attribute__((weak)) int memcmp(const void* s1_, const void* s2_, size_t n) {
+    uint8_t* s1 = (uint8_t*)s1_;
+    const uint8_t* s2 = (uint8_t*)s2_;
+    size_t i;
+
+    for (i = 0; i < n; i++, s1++, s2++) {
+        if (*s1 < *s2) {
+            return -1;
+        } else if (*s1 > *s2) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+__attribute__((weak)) void* memset(void* s_, int c, size_t n) {
+    uint8_t* s = (uint8_t*)s_;
+    size_t i;
+
+    for (i = 0; i < n; i++) *s++ = (uint8_t)c;
+
+    return s_;
+}
+