Merge pull request #2 from SwareJonge/master

Add JKRHeap.cpp

common.py

@@ -332,7 +332,21 @@ SDK_CFLAG = [
 ALIGN16_CFLAG = [
     "-func_align 16",
 ]
+JSYSTEM_BASE = [
+    "-lang=c++",
+    "-inline on",
+    "-fp fmadd",
+    "-fp_contract on",
+    "-pool off",
+    "-Cpp_exceptions off",
+    "-RTTI on",
+    "-char signed",
+    "-enum int",
+    "-sym on", # might also be on for base flags?
+    "-O4,s" # in mkdd some libraries use O4,p, might be the case here too
+]
 
+JSYSTEM_CFLAGS = ' '.join(JSYSTEM_BASE + LOCAL_CFLAGS)
 DOL_CFLAGS = ' '.join(BASE_DOL_CFLAGS + LOCAL_CFLAGS)
 SDK_FLAGS = ' '.join(SDK_CFLAG + LOCAL_CFLAGS)
 ALIGN16 = ' '.join(BASE_DOL_CFLAGS + LOCAL_CFLAGS + ALIGN16_CFLAG)

config/dol_slices.yml

@@ -4,20 +4,25 @@ libultra/gfxprint/gfxprint_locate8x8.c:
     .text: [0x8005B210, 0x8005B238]
 libforest/ReconfigBATs.c:
     .text: [0x8005adac, 0x8005aed4]
+JSystem/JKernel/JKRHeap.cpp:
+    .text: [0x80063748, 0x80064028]
+    .data: [0x800ddf20, 0x800ddf98]
+    .sdata: [0x80217e58, 0x80217e80]
+    .sbss: [0x802186d8, 0x80218700]
 dolphin/BASE/ppcarch.c:
     .text: [0x8007867c, 0x80078718]
-dolphin/OS/OSArena.c:
+dolphin/os/OSArena.c:
     .text: [0x8007988c, 0x800798ac]
     .sdata: [0x80218178, 0x80218180]
     .sbss: [0x802188f8, 0x80218900]
-#dolphin/OS/OSCache.c:
+#dolphin/os/OSCache.c:
 #    .text: [0x80079b40, 0x8007a01c]
 #    .data: [0x800dfa00, 0x800dfc30]
-# OS/OSDisableInterrupts.c:
+#dolphin/os/OSDisableInterrupts.c:
     # .text: [0x8007ac24, 0x8007ac38]
-dolphin/OS/OSEnableInterrupts.c:
+dolphin/os/OSEnableInterrupts.c:
     .text: [0x8007ac38, 0x8007ac4c]
-dolphin/OS/OSRestoreInterrupts.c:
+dolphin/os/OSRestoreInterrupts.c:
     .text: [0x8007ac4c, 0x8007ac70]
 MSL_C/rand.c:
     .text: [0x8009f46c, 0x8009f494]

config/symbols.yml

@@ -2624,7 +2624,23 @@ global:
     0x8009ae00: __save_fpr
     0x8009ae4c: __restore_fpr
     0x8009ae98: __save_gpr
-    0x8009aee4: __restore_gpr
+    0x8009aeb8: _savegpr_22
+    0x8009aebc: _savegpr_23
+    0x8009aec0: _savegpr_24
+    0x8009aec4: _savegpr_25
+    0x8009aec8: _savegpr_26
+    0x8009aecc: _savegpr_27
+    0x8009aed0: _savegpr_28
+    0x8009aed4: _savegpr_29
+    0x8009aee4: __restore_gpr    
+    0x8009af04: _restgpr_22
+    0x8009af08: _restgpr_23
+    0x8009af0c: _restgpr_24
+    0x8009af10: _restgpr_25
+    0x8009af14: _restgpr_26
+    0x8009af18: _restgpr_27
+    0x8009af1c: _restgpr_28
+    0x8009af20: _restgpr_29
     0x8009af30: __div2u
     0x8009b01c: __div2i
     0x8009b154: __mod2u

configure.py

@@ -577,6 +577,9 @@ class CSource(Source):
         if path.startswith("src/dolphin/"):
             self.cflags = c.SDK_FLAGS
             self.cc = c.OCC
+        elif path.startswith("src/JSystem/JKernel/"):
+            self.cflags = c.JSYSTEM_CFLAGS
+            self.cc = c.CC
         elif path.startswith("src/jaudio_NES"):
             self.cc = c.CC
             self.cflags = c.DOL_CPPFLAGS

include/JSystem/JKernel/JKRDisposer.h

@@ -0,0 +1,21 @@
+#ifndef JKRDISPOSER_H
+#define JKRDISPOSER_H
+
+#include "types.h"
+
+#include "JSystem/JSupport/JSUList.h"
+
+class JKRHeap;
+
+class JKRDisposer
+{
+public:
+    JKRDisposer();
+    virtual ~JKRDisposer();
+
+public:
+    JKRHeap *mRootHeap;                 // _4
+    JSULink<JKRDisposer> mPointerLinks; // _8
+};
+
+#endif

include/JSystem/JKernel/JKRHeap.h

@@ -0,0 +1,288 @@
+#ifndef JKRHEAP_H
+#define JKRHEAP_H
+
+#include "dolphin/os/OSMutex.h"
+#include "JSystem/JKernel/JKRDisposer.h"
+
+#include "types.h"
+
+typedef void JKRHeapErrorHandler(void *, u32, int);
+
+class JKRHeap : public JKRDisposer
+{
+public:
+    enum EAllocMode
+    {
+        HEAPALLOC_Unk1 = 1,
+    };
+
+    struct TState
+    { // NB: this struct doesn't agree with TP's struct
+        struct TLocation
+        {
+            TLocation() : _00(nullptr), _04(-1)
+            {
+            }
+
+            void *_00; // _00
+            int _04;   // _04
+        };
+
+        struct TArgument
+        {
+            TArgument(const JKRHeap *heap, u32 p2, bool p3)
+                : mHeap((heap) ? heap : JKRHeap::sCurrentHeap), mId(p2), mIsCompareOnDestructed(p3)
+            {
+            }
+
+            const JKRHeap *mHeap;        // _00
+            u32 mId;                     // _04
+            bool mIsCompareOnDestructed; // _08
+        };
+
+        TState(const JKRHeap *heap, u32 id, bool isCompareOnDestructed)
+            : mUsedSize(0), mCheckCode(0), mArgument(heap, id, isCompareOnDestructed)
+        {
+            mArgument.mHeap->state_register(this, mArgument.mId);
+        }
+
+        TState(JKRHeap *heap)
+            : mUsedSize(0), mCheckCode(0), mArgument(heap, 0xFFFFFFFF, true)
+        {
+        }
+
+        ~TState();
+        void dump() const { mArgument.mHeap->state_dump(*this); }
+        bool isVerbose() { return bVerbose_; };
+        bool isCompareOnDestructed() const { return mArgument.mIsCompareOnDestructed; };
+        u32 getUsedSize() const { return mUsedSize; }
+        u32 getCheckCode() const { return mCheckCode; }
+        const JKRHeap *getHeap() const { return mArgument.mHeap; }
+        u32 getId() const { return mArgument.mId; }
+
+        // unused/inlined:
+        TState(const JKRHeap::TState::TArgument &arg, const JKRHeap::TState::TLocation &location);
+        TState(const JKRHeap::TState &other, bool p2);
+        TState(const JKRHeap::TState &other, const JKRHeap::TState::TLocation &location, bool p3);
+
+        static bool bVerbose_;
+
+        u32 mUsedSize;       // _00
+        u32 mCheckCode;      // _04, plausibly TLocation when combined with _00
+        u32 mBuf;            // _08
+        u8 _0C[0x4];         // _0C
+        TArgument mArgument; // _10
+        TLocation mLocation; // _1C
+    };
+
+public:
+    JKRHeap(void *, u32, JKRHeap *, bool);
+
+    bool setErrorFlag(bool errorFlag);
+    bool isSubHeap(JKRHeap *heap) const;
+
+    virtual ~JKRHeap();
+    virtual void callAllDisposer();
+    virtual void *do_alloc(u32, int) = 0;
+    virtual void do_free(void *) = 0;
+    virtual void do_freeAll() = 0;
+    virtual void do_freeTail() = 0;
+    virtual s32 do_resize(void *, u32) = 0;
+    virtual s32 do_getSize(void *) = 0;
+    virtual s32 do_getFreeSize() = 0;
+    virtual s32 do_getTotalFreeSize() = 0;
+    virtual u32 getHeapType() = 0;
+    virtual bool check() = 0;
+    virtual bool dump_sort() { return true; }
+    virtual bool dump() = 0;
+    virtual s32 do_changeGroupID(u8 newGroupID) { return 0; }
+    virtual u8 do_getCurrentGroupId() { return 0; }
+    virtual void state_register(JKRHeap::TState *, u32) const;
+    virtual bool state_compare(JKRHeap::TState const &, JKRHeap::TState const &) const;
+    virtual void state_dump(JKRHeap::TState const &) const;
+
+    JKRHeap *becomeSystemHeap();
+    JKRHeap *becomeCurrentHeap();
+    void destroy();
+    void *alloc(u32, int);
+    void free(void *);
+    void freeAll();
+    void freeTail();
+    void fillFreeArea();
+    void resize(void *, u32);
+    static s32 getSize(void *, JKRHeap*);
+
+    // ... more functions
+
+    s32 getSize(void *ptr);
+    s32 getFreeSize();
+    void *getMaxFreeBlock();
+    s32 getTotalFreeSize();
+    u8 getCurrentGroupId();
+    s32 changeGroupID(u8 newGroupId);
+    u32 getMaxAllocatableSize(int alignment);
+    JKRHeap *find(void *) const;        // 0x80084640
+    JKRHeap *findAllHeap(void *) const; // 0x8008492c
+    void dispose_subroutine(u32 begin, u32 end);
+    bool dispose(void *, u32);    // 0x80084b9c
+    void dispose(void *, void *); // 0x80084c2c
+    void dispose();               // 0x80084cb8
+
+    void appendDisposer(JKRDisposer *disposer)
+    {
+        mDisposerList.append(&disposer->mPointerLinks);
+    }
+
+    void removeDisposer(JKRDisposer *disposer)
+    {
+        mDisposerList.remove(&disposer->mPointerLinks);
+    }
+
+    void setDebugFill(bool debugFill) { mDebugFill = debugFill; }
+    bool getDebugFill() const { return mDebugFill; }
+    void *getStartAddr() const { return (void *)mStart; }
+    void *getEndAddr() const { return (void *)mEnd; }
+    u32 getHeapSize() const { return mSize; }
+    bool getErrorFlag() const { return mErrorFlag; }
+    void callErrorHandler(JKRHeap *heap, u32 size, int alignment)
+    {
+        if (mErrorHandler)
+        {
+            (*mErrorHandler)(heap, size, alignment);
+        }
+    }
+
+    // Unused
+    void checkMemoryFilled(u8 *, u32 size, u8);
+
+    static void destroy(JKRHeap *heap); // fabricated
+    static bool initArena(char **, u32 *, int);
+    static void *alloc(u32, int, JKRHeap *);
+    static void copyMemory(void *, void *, u32);
+    static void free(void *, JKRHeap *);
+    static void state_dumpDifference(const TState &, const TState &);
+    static JKRHeap *findFromRoot(void *);
+    static JKRHeapErrorHandler *setErrorHandler(JKRHeapErrorHandler *);
+
+    static void *getCodeStart()
+    {
+        return mCodeStart;
+    }
+
+    static void *getCodeEnd()
+    {
+        return mCodeEnd;
+    }
+
+    static void *getUserRamStart()
+    {
+        return mUserRamStart;
+    }
+
+    static void *getUserRamEnd()
+    {
+        return mUserRamEnd;
+    }
+
+    static u32 getMemorySize()
+    {
+        return mMemorySize;
+    }
+
+    static JKRHeap *getCurrentHeap()
+    {
+        return sCurrentHeap;
+    }
+
+    static JKRHeap *getRootHeap()
+    {
+        return sRootHeap;
+    }
+
+    static JKRHeap *getSystemHeap()
+    {
+        return sSystemHeap;
+    }
+
+    static void *mCodeStart;
+    static void *mCodeEnd;
+    static void *mUserRamStart;
+    static void *mUserRamEnd;
+    static u32 mMemorySize;
+
+    static JKRHeap *sSystemHeap;
+    static JKRHeap *sCurrentHeap;
+    static JKRHeap *sRootHeap;
+
+    static bool sDefaultFillFlag;
+    static bool sDefaultFillCheckFlag;
+
+    static JKRHeapErrorHandler *mErrorHandler;
+
+protected:
+    /* 0x00 */ // vtable
+    /* 0x04 */ // JKRDisposer
+    /* 0x18 */ OSMutex mMutex;
+    /* 0x30 */ void *mStart;
+    /* 0x34 */ void *mEnd;
+    /* 0x38 */ u32 mSize;
+    /* 0x3C */ bool mDebugFill;
+    /* 0x3D */ bool mCheckMemoryFilled;
+    /* 0x3E */ u8 mAllocationMode; // EAllocMode?
+    /* 0x3F */ u8 mGroupId;
+    /* 0x40 */ JSUTree<JKRHeap> mChildTree;
+    /* 0x5C */ JSUList<JKRDisposer> mDisposerList;
+    /* 0x68 */ bool mErrorFlag;
+    /* 0x69 */ bool mInitFlag;
+    /* 0x6A */ u8 padding_0x6a[2];
+};
+
+inline JKRHeap *JKRGetCurrentHeap()
+{
+    return JKRHeap::getCurrentHeap();
+}
+
+inline JKRHeap *JKRGetSystemHeap()
+{
+    return JKRHeap::getSystemHeap();
+}
+
+inline JKRHeap *JKRGetRootHeap()
+{
+    return JKRHeap::getRootHeap();
+}
+
+inline void *JKRAllocFromSysHeap(u32 size, int alignment)
+{
+    return JKRHeap::getSystemHeap()->alloc(size, alignment);
+}
+
+inline void *JKRAllocFromHeap(JKRHeap *heap, u32 size, int alignment)
+{
+    return JKRHeap::alloc(size, alignment, heap);
+}
+
+inline void JKRFree(void *pBuf)
+{
+    JKRHeap::free(pBuf, nullptr);
+}
+
+inline void JKRFreeToSysHeap(void *buf)
+{
+    JKRHeap::getSystemHeap()->free(buf);
+}
+
+void JKRDefaultMemoryErrorRoutine(void *, u32, int);
+
+void *operator new(size_t);
+void *operator new(size_t, s32);
+void *operator new(size_t, JKRHeap *, int);
+
+void *operator new[](size_t);
+void *operator new[](size_t, s32);
+void *operator new[](size_t, JKRHeap *, int);
+
+void operator delete(void *);
+void operator delete[](void *);
+
+#endif // !JKRHEAP_H

include/JSystem/JSupport/JSUList.h

@@ -0,0 +1,223 @@
+#ifndef JSULIST_H
+#define JSULIST_H
+
+#include "types.h"
+
+class JSUPtrLink;
+
+class JSUPtrList
+{
+public:
+    JSUPtrList()
+    {
+        initiate();
+    }
+
+    JSUPtrList(bool);
+    ~JSUPtrList();
+
+    void initiate();
+    void setFirst(JSUPtrLink *);
+    bool append(JSUPtrLink *);
+    bool prepend(JSUPtrLink *);
+    bool insert(JSUPtrLink *, JSUPtrLink *);
+    bool remove(JSUPtrLink *);
+    JSUPtrLink *getNthLink(u32 idx) const;
+
+    JSUPtrLink *getFirstLink() const { return mHead; }
+    JSUPtrLink *getLastLink() const { return mTail; }
+    u32 getNumLinks() const { return mLinkCount; }
+
+    JSUPtrLink *mHead; // _0
+    JSUPtrLink *mTail; // _4
+    u32 mLinkCount;    // _8
+};
+
+class JSUPtrLink
+{
+public:
+    JSUPtrLink(void *);
+    ~JSUPtrLink();
+
+    void *getObjectPtr() const { return mData; }
+    JSUPtrList *getList() const { return mPtrList; }
+    JSUPtrLink *getNext() const { return mNext; }
+    JSUPtrLink *getPrev() const { return mPrev; }
+
+    void *mData;          // _0
+    JSUPtrList *mPtrList; // _4
+    JSUPtrLink *mPrev;    // _8
+    JSUPtrLink *mNext;    // _C
+};
+
+template <class T>
+class JSULink; // friend class? i'm C++ noob
+
+template <class T>
+class JSUList : public JSUPtrList
+{
+public:
+    JSUList(bool thing) : JSUPtrList(thing)
+    {
+    }
+    JSUList() : JSUPtrList()
+    {
+    }
+
+    bool append(JSULink<T> *link) { return JSUPtrList::append((JSUPtrLink *)link); }
+    bool prepend(JSULink<T> *link) { return JSUPtrList::prepend((JSUPtrLink *)link); }
+    bool insert(JSULink<T> *before, JSULink<T> *link) { return JSUPtrList::insert((JSUPtrLink *)before, (JSUPtrLink *)link); }
+    bool remove(JSULink<T> *link) { return JSUPtrList::remove((JSUPtrLink *)link); }
+
+    JSULink<T> *getFirst() const { return (JSULink<T> *)getFirstLink(); }
+    JSULink<T> *getLast() const { return (JSULink<T> *)getLastLink(); }
+    JSULink<T> *getEnd() const { return nullptr; }
+
+    u32 getNumLinks() const { return mLinkCount; }
+};
+
+template <typename T>
+class JSUListIterator
+{
+public:
+    JSUListIterator()
+        : mLink(nullptr)
+    {
+    }
+    JSUListIterator(JSULink<T> *link)
+        : mLink(link)
+    {
+    }
+    JSUListIterator(JSUList<T> *list)
+        : mLink(list->getFirst())
+    {
+    }
+
+    JSUListIterator<T> &operator=(JSULink<T> *link)
+    {
+        this->mLink = link;
+        return *this;
+    }
+
+    T *getObject() { return this->mLink->getObject(); }
+
+    bool operator==(JSULink<T> const *other) const { return this->mLink == other; }
+    bool operator!=(JSULink<T> const *other) const { return this->mLink != other; }
+    bool operator==(JSUListIterator<T> const &other) const { return this->mLink == other.mLink; }
+    bool operator!=(JSUListIterator<T> const &other) const { return this->mLink != other.mLink; }
+
+    JSUListIterator<T> operator++(int)
+    {
+        JSUListIterator<T> prev = *this;
+        this->mLink = this->mLink->getNext();
+        return prev;
+    }
+
+    JSUListIterator<T> &operator++()
+    {
+        this->mLink = this->mLink->getNext();
+        return *this;
+    }
+
+    JSUListIterator<T> operator--(int)
+    {
+        JSUListIterator<T> prev = *this;
+        this->mLink = this->mLink->getPrev();
+        return prev;
+    }
+
+    JSUListIterator<T> &operator--()
+    {
+        this->mLink = this->mLink->getPrev();
+        return *this;
+    }
+
+    T &operator*() { return *this->getObject(); }
+
+    T *operator->() { return this->getObject(); }
+
+    // private:
+    JSULink<T> *mLink;
+};
+
+template <class T>
+class JSULink : public JSUPtrLink
+{
+public:
+    JSULink(void *pData) : JSUPtrLink(pData)
+    {
+    }
+
+    T *getObject() const { return (T *)mData; }
+    JSUList<T> *getList() const { return (JSUList<T> *)JSUPtrLink::getList(); } // fabricated, offcial name: getSupervisor
+    JSULink<T> *getNext() const { return (JSULink<T> *)JSUPtrLink::getNext(); }
+    JSULink<T> *getPrev() const { return (JSULink<T> *)JSUPtrLink::getPrev(); }
+
+    ~JSULink()
+    {
+    }
+};
+
+template <typename T> // TODO: most of these inlines are probably wrong: rework
+class JSUTree : public JSUList<T>, public JSULink<T>
+{
+public:
+    JSUTree(T *owner) : JSUList<T>(), JSULink<T>(owner) {}
+    ~JSUTree() {}
+
+    bool appendChild(JSUTree<T> *child) { return this->append(child); }
+    bool prependChild(JSUTree<T> *child) { return this->prepend(child); }
+    bool removeChild(JSUTree<T> *child) { return this->remove(child); }
+    bool insertChild(JSUTree<T> *before, JSUTree<T> *child) { return this->insert(before, child); }
+
+    JSUTree<T> *getEndChild() const { return nullptr; }
+    JSUTree<T> *getFirstChild() const { return (JSUTree<T> *)getFirstLink(); }
+    JSUTree<T> *getLastChild() const { return (JSUTree<T> *)this->getLast(); }
+    JSUTree<T> *getNextChild() const { return (JSUTree<T> *)mNext; }
+    JSUTree<T> *getPrevChild() const { return (JSUTree<T> *)this->getPrev(); }
+    u32 getNumChildren() const { return mLinkCount; }
+    T *getObject() const { return (T *)this->mData; }
+    JSUTree<T> *getParent() const { return (JSUTree<T> *)this->mPtrList; }
+};
+
+template <typename T>
+class JSUTreeIterator
+{
+public:
+    JSUTreeIterator() : mTree(nullptr) {}
+    JSUTreeIterator(JSUTree<T> *tree) : mTree(tree) {}
+
+    JSUTreeIterator<T> &operator=(JSUTree<T> *tree)
+    {
+        this->mTree = tree;
+        return *this;
+    }
+
+    T *getObject() const { return mTree->getObject(); }
+
+    bool operator==(JSUTree<T> *other) { return this->mTree == other; }
+
+    bool operator!=(const JSUTree<T> *other) const { return this->mTree != other; }
+
+    JSUTreeIterator<T> operator++(int)
+    {
+        JSUTreeIterator<T> prev = *this;
+        this->mTree = this->mTree->getNextChild();
+        return prev;
+    }
+
+    JSUTreeIterator<T> &operator++()
+    {
+        this->mTree = this->mTree->getNextChild();
+        return *this;
+    }
+
+    T &operator*() { return *this->getObject(); }
+
+    T *operator->() const { return mTree->getObject(); }
+
+private:
+    JSUTree<T> *mTree;
+};
+
+#endif /* JSULIST_H */

include/JSystem/JUT/JUTAssertion.h

@@ -1,6 +1,29 @@
 #ifndef _JSYSTEM_JUT_JUTASSERTION_H
 #define _JSYSTEM_JUT_JUTASSERTION_H
 
-void JC_JUTAssertion_changeDevice(u32); 
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+void JC_JUTAssertion_changeDevice(u32);
+
+#define JUT_PANIC(...)
+#define JUT_PANIC_F(...)
+#define JUT_CONFIRM_MESSAGE(...)
+#define JUT_WARNING(...)
+#define JUT_WARNING_F(...)
+#define JUT_ASSERT(...)
+#define JUT_ASSERT_F(...)
+#define JUT_ASSERT_MSG(...)
+#define JUT_MINMAX_ASSERT(...)
+#define JUT_MAX_ASSERT(...)
+#define JUT_LOG_F(...)
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif

include/dolphin/os.h

@@ -1,28 +1,31 @@
-#ifndef _DOLPHIN_OS
-#define _DOLPHIN_OS
-
-#include "types.h"
-#include "dolphin/OS/OSContext.h"
-#include "va_args.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void OSReport(const char*, ...);
-void OSVReport(const char* format, va_list list);
-
-asm BOOL OSDisableInterrupts(void);
-asm BOOL OSEnableInterrupts(void);
-asm BOOL OSRestoreInterrupts(BOOL level);
-
-
-void __RAS_OSDisableInterrupts_begin(void);
-void __RAS_OSDisableInterrupts_end(void);
-
-typedef void (*OSExceptionHandler)(u8, OSContext*);
-OSExceptionHandler __OSSetExceptionHandler(u8, OSExceptionHandler);
-
-#ifdef __cplusplus
-};
-#endif
-#endif
+#ifndef _DOLPHIN_OS
+#define _DOLPHIN_OS
+
+#include "types.h"
+#include "dolphin/os/OSContext.h"
+#include "va_args.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void OSPanic(const char *file, int line, const char *message, ...);
+void OSReport(const char*, ...);
+void OSVReport(const char* format, va_list list);
+
+#define OSErrorLine(line, ...) \
+    OSPanic(__FILE__, line, __VA_ARGS__)
+
+asm BOOL OSDisableInterrupts(void);
+asm BOOL OSEnableInterrupts(void);
+asm BOOL OSRestoreInterrupts(BOOL level);
+
+void __RAS_OSDisableInterrupts_begin(void);
+void __RAS_OSDisableInterrupts_end(void);
+
+typedef void (*OSExceptionHandler)(u8, OSContext*);
+OSExceptionHandler __OSSetExceptionHandler(u8, OSExceptionHandler);
+
+#ifdef __cplusplus
+};
+#endif
+#endif

include/dolphin/os/OSAddress.h

@@ -0,0 +1,32 @@
+#ifndef OS_ADDRESS_H
+#define OS_ADDRESS_H
+
+// maybe put this in OSUtil instead
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// Defines for cached and uncached memory.
+#define OS_BASE_CACHED (0x80000000)
+#define OS_BASE_UNCACHED (0xC0000000)
+
+// Address conversions.
+#define OSPhysicalToCached(paddr) ((void *)((u32)(paddr) + OS_BASE_CACHED))
+#define OSPhysicalToUncached(paddr) ((void *)((u32)(paddr) + OS_BASE_UNCACHED))
+#define OSCachedToPhysical(caddr) ((u32)((u8 *)(caddr)-OS_BASE_CACHED))
+#define OSUncachedToPhysical(ucaddr) ((u32)((u8 *)(ucaddr)-OS_BASE_UNCACHED))
+#define OSCachedToUncached(caddr) ((void *)((u8 *)(caddr) + (OS_BASE_UNCACHED - OS_BASE_CACHED)))
+#define OSUncachedToCached(ucaddr) ((void *)((u8 *)(ucaddr) - (OS_BASE_UNCACHED - OS_BASE_CACHED)))
+
+#define OS_CACHED_REGION_PREFIX 0x8000
+#define OS_UNCACHED_REGION_PREFIX 0xC000
+#define OS_PHYSICAL_MASK 0x3FFF
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

include/dolphin/os/OSAlloc.h

@@ -0,0 +1,15 @@
+#ifndef OS_ALLOC_H
+#define OS_ALLOC_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    void *OSInitAlloc(void *, void *, int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/dolphin/os/OSArena.h

@@ -1,18 +1,18 @@
-#ifndef OS_ARENA_H
-#define OS_ARENA_H
-#include "types.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif
-
-void* OSGetArenaHi(void);
-void* OSGetArenaLo(void);
-
-void OSSetArenaHi(void*);
-void OSSetArenaLo(void*);
-
-#ifdef __cplusplus
-}
-#endif
+#ifndef OS_ARENA_H
+#define OS_ARENA_H
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+void* OSGetArenaHi(void);
+void* OSGetArenaLo(void);
+
+void OSSetArenaHi(void*);
+void OSSetArenaLo(void*);
+
+#ifdef __cplusplus
+}
+#endif
 #endif

include/dolphin/os/OSCache.h

@@ -1,30 +1,30 @@
-#ifndef OS_CACHE_H
-#define OS_CACHE_H
-#include "types.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-asm void DCEnable(void);
-asm void DCInvalidateRange(void*, u32);
-asm void DCFlushRange(void*, u32);
-asm void DCStoreRange(void*, u32);
-asm void DCFlushRangeNoSync(void*, u32);
-asm void DCStoreRangeNoSync(void*, u32);
-asm void DCZeroRange(void*, u32);
-asm void DCTouchRange(void*, u32 len);
-asm void ICInvalidateRange(void*, u32);
-asm void ICFlashInvalidate(void);
-asm void ICEnable(void);
-asm void LCDisable(void);
-
-//void L2GlobalInvalidate(void);
-
-//void DMAErrorHandler(u8, struct OSContext*, u32, u32, ...);
-
-//void __OSCacheInit(void);
-
-#ifdef __cplusplus
-}
-#endif
-#endif
+#ifndef OS_CACHE_H
+#define OS_CACHE_H
+#include "types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+asm void DCEnable(void);
+asm void DCInvalidateRange(void*, u32);
+asm void DCFlushRange(void*, u32);
+asm void DCStoreRange(void*, u32);
+asm void DCFlushRangeNoSync(void*, u32);
+asm void DCStoreRangeNoSync(void*, u32);
+asm void DCZeroRange(void*, u32);
+asm void DCTouchRange(void*, u32 len);
+asm void ICInvalidateRange(void*, u32);
+asm void ICFlashInvalidate(void);
+asm void ICEnable(void);
+asm void LCDisable(void);
+
+//void L2GlobalInvalidate(void);
+
+//void DMAErrorHandler(u8, struct OSContext*, u32, u32, ...);
+
+//void __OSCacheInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

include/dolphin/os/OSContext.h

@@ -1,45 +1,45 @@
-#ifndef OS_CONTEXT_H
-#define OS_CONTEXT_H
-#include "types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct OSContext{
-	u32 gprs[32];
-	u32 cr;
-	u32 lr;
-	u32 ctr;
-	u32 xer;
-	f64 fprs[32];
-	u32 fpscr_tmp;
-	u32 fpscr;
-	u32 srr0;
-	u32 srr1;
-	u16 mode;
-	u16 state;
-	u32 gqrs[8];
-	char UNK_0x1C4;
-	f64 psfs[32];
-} OSContext;
-
-OSContext* OS_CURRENT_CONTEXT_PHYS : 0x800000C0;
-OSContext* OS_CURRENT_CONTEXT : 0x800000D4;
-OSContext* OS_CURRENT_FPU_CONTEXT : 0x800000D8;
-
-void OSSaveFPUContext(OSContext*);
-void OSSetCurrentContext(OSContext*);
-OSContext* OSGetCurrentContext(void);
-BOOL OSSaveContext(OSContext*);
-void OSLoadContext(OSContext*);
-void* OSGetStackPointer(void);
-void OSClearContext(OSContext*);
-void OSInitContext(register OSContext*, register u32 srr, register u32 sp);
-void OSDumpContext(const OSContext*);
-
-void __OSContextInit(void);
-#ifdef __cplusplus
-};
-#endif
-#endif
+#ifndef OS_CONTEXT_H
+#define OS_CONTEXT_H
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OSContext{
+	u32 gprs[32];
+	u32 cr;
+	u32 lr;
+	u32 ctr;
+	u32 xer;
+	f64 fprs[32];
+	u32 fpscr_tmp;
+	u32 fpscr;
+	u32 srr0;
+	u32 srr1;
+	u16 mode;
+	u16 state;
+	u32 gqrs[8];
+	char UNK_0x1C4;
+	f64 psfs[32];
+} OSContext;
+
+OSContext* OS_CURRENT_CONTEXT_PHYS : 0x800000C0;
+OSContext* OS_CURRENT_CONTEXT : 0x800000D4;
+OSContext* OS_CURRENT_FPU_CONTEXT : 0x800000D8;
+
+void OSSaveFPUContext(OSContext*);
+void OSSetCurrentContext(OSContext*);
+OSContext* OSGetCurrentContext(void);
+BOOL OSSaveContext(OSContext*);
+void OSLoadContext(OSContext*);
+void* OSGetStackPointer(void);
+void OSClearContext(OSContext*);
+void OSInitContext(register OSContext*, register u32 srr, register u32 sp);
+void OSDumpContext(const OSContext*);
+
+void __OSContextInit(void);
+#ifdef __cplusplus
+};
+#endif
+#endif

include/dolphin/os/OSMemory.h

@@ -1,17 +1,17 @@
-#ifndef OS_MEMORY_H
-#define OS_MEMORY_H
-#include "types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define SIM_MEM *(u32 *)0x800000f0 
-static asm void Config24MB();
-static asm void Config48MB();
-u32 OSGetConsoleSimulatedMemSize(void);
-
-#ifdef __cplusplus
-}
-#endif
+#ifndef OS_MEMORY_H
+#define OS_MEMORY_H
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SIM_MEM *(u32 *)0x800000f0 
+static asm void Config24MB();
+static asm void Config48MB();
+u32 OSGetConsoleSimulatedMemSize(void);
+
+#ifdef __cplusplus
+}
+#endif
 #endif

include/dolphin/os/OSMutex.h

@@ -0,0 +1,36 @@
+#ifndef OS_MUTEX_H
+#define OS_MUTEX_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "dolphin/os/OSThread.h"
+
+    struct OSMutex
+    {
+        OSThreadQueue queue;
+        OSThread *thread; // the current owner
+        s32 count;        // lock count
+        OSMutexLink link; // for OSThread.queueMutex
+    };
+
+    struct OSCond
+    {
+        OSThreadQueue queue;
+    };
+
+    void OSInitMutex(OSMutex *mutex);
+    void OSLockMutex(OSMutex *mutex);
+    void OSUnlockMutex(OSMutex *mutex);
+    BOOL OSTryLockMutex(OSMutex *mutex);
+    void OSInitCond(OSCond *cond);
+    void OSWaitCond(OSCond *cond, OSMutex *mutex);
+    void OSSignalCond(OSCond *cond);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // DOLPHIN_OSMUTEX_H

include/dolphin/os/OSThread.h

@@ -0,0 +1,129 @@
+#ifndef OS_THREAD_H
+#define OS_THREAD_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "dolphin/os/OSContext.h"
+
+    typedef struct OSThread OSThread;
+    typedef struct OSThreadQueue OSThreadQueue;
+    typedef struct OSThreadLink OSThreadLink;
+    typedef s32 OSPriority; //  0 highest, 31 lowest
+
+    typedef struct OSMutex OSMutex;
+    typedef struct OSMutexQueue OSMutexQueue;
+    typedef struct OSMutexLink OSMutexLink;
+    typedef struct OSCond OSCond;
+
+    typedef void (*OSIdleFunction)(void *param);
+
+    struct OSThreadQueue
+    {
+        OSThread *head;
+        OSThread *tail;
+    };
+
+    struct OSThreadLink
+    {
+        OSThread *next;
+        OSThread *prev;
+    };
+
+    struct OSMutexQueue
+    {
+        OSMutex *head;
+        OSMutex *tail;
+    };
+
+    struct OSMutexLink
+    {
+        OSMutex *next;
+        OSMutex *prev;
+    };
+
+    struct OSThread
+    {
+        OSContext context; // register context
+
+        u16 state;           // OS_THREAD_STATE_*
+        u16 attr;            // OS_THREAD_ATTR_*
+        s32 suspend;         // suspended if the count is greater than zero
+        OSPriority priority; // effective scheduling priority
+        OSPriority base;     // base scheduling priority
+        void *val;           // exit value
+
+        OSThreadQueue *queue; // queue thread is on
+        OSThreadLink link;    // queue link
+
+        OSThreadQueue queueJoin; // list of threads waiting for termination (join)
+
+        OSMutex *mutex;          // mutex trying to lock
+        OSMutexQueue queueMutex; // list of mutexes owned
+
+        OSThreadLink linkActive; // link of all threads for debugging
+
+        u8 *stackBase; // the thread's designated stack (high address)
+        u32 *stackEnd; // last word of stack (low address)
+    };
+
+    // Thread states
+    enum OS_THREAD_STATE
+    {
+        OS_THREAD_STATE_READY = 1,
+        OS_THREAD_STATE_RUNNING = 2,
+        OS_THREAD_STATE_WAITING = 4,
+        OS_THREAD_STATE_MORIBUND = 8
+    };
+
+// Thread priorities
+#define OS_PRIORITY_MIN 0  // highest
+#define OS_PRIORITY_MAX 31 // lowest
+#define OS_PRIORITY_IDLE OS_PRIORITY_MAX
+
+// Thread attributes
+#define OS_THREAD_ATTR_DETACH 0x0001u // detached
+
+// Stack magic value
+#define OS_THREAD_STACK_MAGIC 0xDEADBABE
+
+    void OSInitThreadQueue(OSThreadQueue *queue);
+    OSThread *OSGetCurrentThread(void);
+    BOOL OSIsThreadSuspended(OSThread *thread);
+    BOOL OSIsThreadTerminated(OSThread *thread);
+    s32 OSDisableScheduler(void);
+    s32 OSEnableScheduler(void);
+    void OSYieldThread(void);
+    BOOL OSCreateThread(OSThread *thread,
+                        void *(*func)(void *),
+                        void *param,
+                        void *stack,
+                        u32 stackSize,
+                        OSPriority priority,
+                        u16 attr);
+    void OSExitThread(void *val);
+    void OSCancelThread(OSThread *thread);
+    BOOL OSJoinThread(OSThread *thread, void **val);
+    void OSDetachThread(OSThread *thread);
+    s32 OSResumeThread(OSThread *thread);
+    s32 OSSuspendThread(OSThread *thread);
+    BOOL OSSetThreadPriority(OSThread *thread, OSPriority priority);
+    OSPriority OSGetThreadPriority(OSThread *thread);
+    void OSSleepThread(OSThreadQueue *queue);
+    void OSWakeupThread(OSThreadQueue *queue);
+
+    OSThread *OSSetIdleFunction(OSIdleFunction idleFunction,
+                                void *param,
+                                void *stack,
+                                u32 stackSize);
+    OSThread *OSGetIdleFunction(void);
+
+    long OSCheckActiveThreads(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // DOLPHIN_OSTHREAD_H

include/dolphin/os/OSTime.h

@@ -1,14 +1,14 @@
-#ifndef OS_TIME_H
-#define OS_TIME_H
-#include "types.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef s64 OSTime;
-OSTime OSGetTime(void);
-
-#ifdef __cplusplus
-}
-#endif
+#ifndef OS_TIME_H
+#define OS_TIME_H
+#include "types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef s64 OSTime;
+OSTime OSGetTime(void);
+
+#ifdef __cplusplus
+}
+#endif
 #endif

include/dolphin/os/OSUtil.h

@@ -0,0 +1,18 @@
+#ifndef OS_UTIL_H
+#define OS_UTIL_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define OSRoundUp32B(x) (((u32)(x) + 0x1F) & ~(0x1F))
+#define OSRoundDown32B(x) (((u32)(x)) & ~(0x1F))
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

include/libforest/batconfig.h

@@ -2,8 +2,8 @@
 #define BATCONFIG_H
 
 #include "types.h"
-#include "dolphin/OS/OSMemory.h"
-#include "dolphin/OS/os.h"
+#include "dolphin/os/OSMemory.h"
+#include "dolphin/os.h"
 
 asm void Config24MB();
 asm void Config48MB();

include/libultra/libultra.h

@@ -2,8 +2,8 @@
 #define LIBULTRA_H
 
 #include "types.h"
-#include "dolphin/OS/OSTime.h"
-#include "dolphin/OS/OSCache.h"
+#include "dolphin/os/OSTime.h"
+#include "dolphin/os/OSCache.h"
 
 int bcmp (void *v1, void *v2, u32 size);
 void bcopy(void *dst, void *src, size_t n);

include/zurumode.h

@@ -3,7 +3,7 @@
 
 #include "types.h"
 
-#include "dolphin/OS/os.h"
+#include "dolphin/os.h"
 //#include "JSystem/JUT/JUTAssertion.h"
 //#include "JSystem/JUT/JUTDbPrint.h"
 

src/JSystem/JKernel/JKRHeap.cpp

@@ -0,0 +1,426 @@
+#include "JSystem/JUT/JUTAssertion.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "dolphin/os.h"
+#include "dolphin/os/OSArena.h"
+#include "dolphin/os/OSAlloc.h"
+#include "dolphin/os/OSMemory.h"
+#include "dolphin/os/OSUtil.h"
+#include "dolphin/os/OSAddress.h"
+
+JKRHeap *JKRHeap::sSystemHeap;
+JKRHeap *JKRHeap::sCurrentHeap;
+JKRHeap *JKRHeap::sRootHeap;
+JKRHeapErrorHandler *JKRHeap::mErrorHandler;
+void *JKRHeap::mCodeStart;
+void *JKRHeap::mCodeEnd;
+void *JKRHeap::mUserRamStart;
+void *JKRHeap::mUserRamEnd;
+u32 JKRHeap::mMemorySize;
+
+bool JKRHeap::sDefaultFillFlag = true;
+
+JKRHeap::JKRHeap(void *data, u32 size, JKRHeap *heap, bool errorFlag) : JKRDisposer(),
+                                                                        mChildTree(this),
+                                                                        mDisposerList()
+{
+    OSInitMutex(&mMutex);
+    mSize = size;
+    mStart = (u8 *)data;
+    mEnd = ((u8 *)data + size);
+    if (heap == nullptr)
+    {
+        becomeSystemHeap();
+        becomeCurrentHeap();
+    }
+    else
+    {
+        heap->mChildTree.appendChild(&mChildTree);
+        if (sSystemHeap == sRootHeap)
+            becomeSystemHeap();
+        if (sCurrentHeap == sRootHeap)
+            becomeCurrentHeap();
+    }
+    mErrorFlag = errorFlag;
+    if (mErrorFlag == true && mErrorHandler == nullptr)
+        mErrorHandler = JKRDefaultMemoryErrorRoutine;
+    mDebugFill = sDefaultFillFlag;
+    mInitFlag = false;
+}
+
+JKRHeap::~JKRHeap()
+{
+    mChildTree.getParent()->removeChild(&mChildTree);
+    JSUTree<JKRHeap> *nextRootHeap = sRootHeap->mChildTree.getFirstChild();
+    if (sCurrentHeap == this)
+        sCurrentHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
+
+    if (sSystemHeap == this)
+        sSystemHeap = !nextRootHeap ? sRootHeap : nextRootHeap->getObject();
+}
+
+bool JKRHeap::initArena(char **outUserRamStart, u32 *outUserRamSize, int numHeaps)
+{
+    void *arenaLo = OSGetArenaLo();
+    void *arenaHi = OSGetArenaHi();
+    if (arenaLo == arenaHi)
+    {
+        return false;
+    }
+    void *arenaStart = OSInitAlloc(arenaLo, arenaHi, numHeaps);
+    arenaHi = (u8 *)OSRoundDown32B(arenaHi);
+    arenaLo = (u8 *)OSRoundUp32B(arenaStart);
+    u8 *start = (u8 *)OSPhysicalToCached(0);
+    mCodeStart = (u8 *)start;
+    mCodeEnd = (u8 *)arenaLo;
+    mUserRamStart = (u8 *)arenaLo;
+    mUserRamEnd = (u8 *)arenaHi;
+    mMemorySize = *(u32 *)((start + 0x28));
+    OSSetArenaLo(arenaHi);
+    OSSetArenaHi(arenaHi);
+    *outUserRamStart = (char *)arenaLo;
+    *outUserRamSize = (u32)arenaHi - (u32)arenaLo;
+    return true;
+}
+
+JKRHeap *JKRHeap::becomeSystemHeap()
+{
+    JKRHeap *old = sSystemHeap;
+    sSystemHeap = this;
+    return old;
+}
+
+JKRHeap *JKRHeap::becomeCurrentHeap()
+{
+    JKRHeap *old = sCurrentHeap;
+    sCurrentHeap = this;
+    return old;
+}
+
+void JKRHeap::destroy(JKRHeap *heap)
+{
+    JUT_ASSERT(200, heap != 0);
+    heap->destroy();
+}
+
+void *JKRHeap::alloc(u32 byteCount, int padding, JKRHeap *heap)
+{
+    void *memory = nullptr;
+    if (heap)
+    {
+        memory = heap->do_alloc(byteCount, padding);
+    }
+    else if (sCurrentHeap)
+    {
+        memory = sCurrentHeap->do_alloc(byteCount, padding);
+    }
+    return memory;
+}
+
+void *JKRHeap::alloc(u32 byteCount, int padding)
+{
+    JUT_WARNING_F(317, !mInitFlag, "alloc %x byte in heap %x", byteCount, this);
+    return do_alloc(byteCount, padding);
+}
+
+void JKRHeap::free(void *memory, JKRHeap *heap)
+{
+    if ((heap) || (heap = findFromRoot(memory), heap))
+    {
+        heap->free(memory);
+    }
+}
+
+void JKRHeap::free(void *memory)
+{
+    JUT_WARNING_F(365, !mInitFlag, "free %x in heap %x", memory, this);
+    do_free(memory);
+}
+
+void JKRHeap::callAllDisposer()
+{
+    JSUListIterator<JKRDisposer> iterator;
+    while (iterator = mDisposerList.getFirst(), iterator != mDisposerList.getEnd())
+    {
+        iterator->~JKRDisposer();
+    }
+}
+
+void JKRHeap::freeAll()
+{
+    JUT_WARNING_F(417, !mInitFlag, "freeAll in heap %x", this);
+    do_freeAll();
+}
+
+void JKRHeap::freeTail()
+{
+    JUT_WARNING_F(431, !mInitFlag, "freeTail in heap %x", this);
+    do_freeTail();
+}
+
+void JKRHeap::resize(void *memoryBlock, u32 newSize)
+{
+    JUT_WARNING_F(491, !mInitFlag, "resize block %x into %x in heap %x", memoryBlock, newSize, this);
+    do_resize(memoryBlock, newSize);
+}
+
+s32 JKRHeap::getSize(void *memoryBlock, JKRHeap *heap)
+{
+    if (heap == nullptr && (heap = findFromRoot(memoryBlock), heap == nullptr))
+    {
+        return -1;
+    }
+    else
+        return heap->getSize(memoryBlock);
+}
+
+s32 JKRHeap::getSize(void *memoryBlock) { return do_getSize(memoryBlock); }
+s32 JKRHeap::getFreeSize() { return do_getFreeSize(); }
+s32 JKRHeap::getTotalFreeSize() { return do_getTotalFreeSize(); }
+
+s32 JKRHeap::changeGroupID(u8 newGroupID)
+{
+    JUT_WARNING_F(570, !mInitFlag, "change heap ID into %x in heap %x", newGroupID, this);
+    return do_changeGroupID(newGroupID);
+}
+
+u8 JKRHeap::getCurrentGroupId() { return do_getCurrentGroupId(); }
+
+JKRHeap *JKRHeap::findFromRoot(void *ptr)
+{
+    if (sRootHeap != nullptr)
+        return sRootHeap->find(ptr);
+
+    return nullptr;
+}
+
+JKRHeap *JKRHeap::find(void *memory) const
+{
+    if ((mStart <= memory) && (memory <= mEnd))
+    {
+        if (mChildTree.getNumChildren() != 0)
+        {
+            for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild()); iterator != mChildTree.getEndChild(); ++iterator)
+            {
+                JKRHeap *result = iterator->find(memory);
+                if (result)
+                {
+                    return result;
+                }
+            }
+        }
+        return const_cast<JKRHeap *>(this);
+    }
+    return nullptr;
+}
+
+JKRHeap *JKRHeap::findAllHeap(void *memory) const
+{
+    if (mChildTree.getNumChildren() != 0)
+    {
+        for (JSUTreeIterator<JKRHeap> iterator(mChildTree.getFirstChild()); iterator != mChildTree.getEndChild(); ++iterator)
+        {
+            JKRHeap *result = iterator->findAllHeap(memory);
+            if (result)
+            {
+                return result;
+            }
+        }
+    }
+
+    if (mStart <= memory && memory < mEnd)
+    {
+        return const_cast<JKRHeap *>(this);
+    }
+
+    return nullptr;
+}
+
+// generates __as__25JSUTreeIterator<7JKRHeap>FP17JSUTree<7JKRHeap> and __ct__25JSUTreeIterator<7JKRHeap>Fv, remove this
+void JKRHeap::dispose_subroutine(u32 begin, u32 end)
+{
+    JSUListIterator<JKRDisposer> last_iterator;
+    JSUListIterator<JKRDisposer> next_iterator;
+    JSUListIterator<JKRDisposer> iterator;
+    for (iterator = mDisposerList.getFirst(); iterator != mDisposerList.getEnd();
+         iterator = next_iterator)
+    {
+        JKRDisposer *disposer = iterator.getObject();
+
+        if ((void *)begin <= disposer && disposer < (void *)end)
+        {
+            disposer->~JKRDisposer();
+            if (last_iterator == nullptr)
+            {
+                next_iterator = mDisposerList.getFirst();
+            }
+            else
+            {
+                next_iterator = last_iterator;
+                next_iterator++;
+            }
+        }
+        else
+        {
+            last_iterator = iterator;
+            next_iterator = iterator;
+            next_iterator++;
+        }
+    }
+}
+
+bool JKRHeap::dispose(void *memory, u32 size)
+{
+    u32 begin = (u32)memory;
+    u32 end = (u32)memory + size;
+    dispose_subroutine(begin, end);
+    return false;
+}
+
+void JKRHeap::dispose(void *begin, void *end)
+{
+    dispose_subroutine((u32)begin, (u32)end);
+}
+
+void JKRHeap::dispose()
+{
+    JSUListIterator<JKRDisposer> iterator;
+    while (iterator = mDisposerList.getFirst(), iterator != mDisposerList.getEnd())
+    {
+        iterator->~JKRDisposer();
+    }
+}
+
+void JKRHeap::copyMemory(void *dst, void *src, u32 size)
+{
+    u32 count = (size + 3) / 4;
+
+    u32 *dst_32 = (u32 *)dst;
+    u32 *src_32 = (u32 *)src;
+    while (count > 0)
+    {
+        *dst_32 = *src_32;
+        dst_32++;
+        src_32++;
+        count--;
+    }
+}
+
+void JKRDefaultMemoryErrorRoutine(void *heap, u32 size, int alignment)
+{
+    // OSReport("Error: Cannot allocate memory %d(0x%x)byte in %d byte alignment from %08x\n", size, size, alignment, heap);
+    OSErrorLine(710, "abort\n");
+}
+
+JKRHeapErrorHandler *JKRHeap::setErrorHandler(JKRHeapErrorHandler *newHandler)
+{
+    JKRHeapErrorHandler *oldHandler = mErrorHandler;
+    if (!newHandler)
+    {
+        newHandler = JKRDefaultMemoryErrorRoutine;
+    }
+    mErrorHandler = newHandler;
+    return oldHandler;
+}
+
+bool JKRHeap::isSubHeap(JKRHeap *heap) const
+{
+    if (!heap)
+        return false;
+
+    if (mChildTree.getNumChildren() != 0)
+    {
+        JSUTreeIterator<JKRHeap> iterator;
+        for (iterator = mChildTree.getFirstChild(); iterator != mChildTree.getEndChild(); ++iterator)
+        {
+            if (iterator.getObject() == heap)
+            {
+                return true;
+            }
+
+            if (iterator.getObject()->isSubHeap(heap))
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+void *operator new(u32 byteCount)
+{
+    return JKRHeap::alloc(byteCount, 4, nullptr);
+}
+void *operator new(u32 byteCount, int alignment)
+{
+    return JKRHeap::alloc(byteCount, alignment, nullptr);
+}
+void *operator new(u32 byteCount, JKRHeap *heap, int alignment)
+{
+    return JKRHeap::alloc(byteCount, alignment, heap);
+}
+
+void *operator new[](u32 byteCount)
+{
+    return JKRHeap::alloc(byteCount, 4, nullptr);
+}
+void *operator new[](u32 byteCount, int alignment)
+{
+    return JKRHeap::alloc(byteCount, alignment, nullptr);
+}
+void *operator new[](u32 byteCount, JKRHeap *heap, int alignment)
+{
+    return JKRHeap::alloc(byteCount, alignment, heap);
+}
+
+// this is not needed without the other pragma and asm bs
+void operator delete(void *memory) { JKRHeap::free(memory, nullptr); }
+void operator delete[](void *memory) { JKRHeap::free(memory, nullptr); }
+
+/*JKRHeap::TState::TState(const JKRHeap::TState::TArgument &arg, const JKRHeap::TState::TLocation &location)
+{
+    // UNUSED FUNCTION
+}
+
+JKRHeap::TState::TState(const JKRHeap::TState &other, bool p2)
+{
+    // UNUSED FUNCTION
+}
+
+JKRHeap::TState::TState(const JKRHeap::TState &other, const JKRHeap::TState::TLocation &location, bool p3)
+{
+    // UNUSED FUNCTION
+}*/
+
+JKRHeap::TState::~TState()
+{
+    // Unused, however might need it
+}
+
+void JKRHeap::state_register(JKRHeap::TState *p, u32) const
+{
+    JUT_ASSERT(1132, p != 0);
+    JUT_ASSERT(1133, p->getHeap() == this);
+}
+
+bool JKRHeap::state_compare(const JKRHeap::TState &r1, const JKRHeap::TState &r2) const
+{
+    JUT_ASSERT(1141, r1.getHeap() == r2.getHeap());
+    return (r1.getCheckCode() == r2.getCheckCode());
+}
+
+// fabricated, but probably matches(except for line numbers)
+void JKRHeap::state_dumpDifference(const JKRHeap::TState &r1, const JKRHeap::TState &r2)
+{
+    JUT_LOG_F(1157, "heap       : %p / %p", r1.getHeap(), r2.getHeap());
+    JUT_LOG_F(1158, "check-code : 0x%08x / 0x%08x", r1.getCheckCode(), r2.getCheckCode());
+    JUT_LOG_F(1159, "id         : 0x%08x / 0x%08x", r1.getId(), r2.getId());
+    JUT_LOG_F(1160, "used size  : %10u / %10u", r1.getUsedSize(), r2.getUsedSize());
+}
+
+void JKRHeap::state_dump(const TState &state) const
+{
+    JUT_LOG_F(1165, "check-code : 0x%08x", state.getCheckCode());
+    JUT_LOG_F(1166, "id         : 0x%08x", state.getId());
+    JUT_LOG_F(1167, "used size  : %u", state.getUsedSize());
+}

src/dolphin/os/OSAlarm.c

@@ -1,171 +1,171 @@
-#include "dolphin/OS/OSAlarm.h"
-#include "dolphin/OS/OSTime.h"
-#include "dolphin/OS/OSContext.h"
-
-static void DecrementerExceptionHandler(u8, OSContext*);
-
-void OSInitAlarm(void){
-	
-	if (__OSGetExceptionHandler(8) |= DecrementerExceptionHandler){
-		AlarmQueue.tail = 0;
-		AlarmQueue.head = 0;
-		__OSSetExceptionHandler(8, DecrementerExceptionHandler);
-	}
-}
-void OSCreateAlarm(OSAlarm* alarm){
-	alarm->handler = NULL;
-}
-
-static void InsertAlarm(OSAlarm* alarm, OSTime fire, OSAlarmHandler handler){
-	OSAlarm* next;
-	OSAlarm* prev;
-	
-	if (0 < alarm->period) {
-		OSTime time = __OSGetSystemTime();
-		
-		fire = alarm->start;
-		if (alarm->start < time) {
-			fire += alarm->period * ((time - alarm->start) / alarm->period + 1);
-		}
-}
-
-	alarm->handler = handler;
-	alarm->fire = fire;
-	
-	for (next = AlarmQueue.head; next; next = next->next){
-		if (next->fire <= fire) {
-			continue;
-		}
-		alarm->prev = next->prev;
-		next->prev = alarm;
-		alarm->next = next;
-		prev = alarm->prev;
-		if (prev) {
-			prev->next = alarm;
-		}
-		else{
-			AlarmQueue.head = alarm;
-			SetTimer(alarm);
-		}
-		return;
-	}
-	alarm->next = 0;
-	prev = AlarmQueue.tail;
-	AlarmQueue.tail = alarm;
-	alarm->prev = prev;
-	if (prev) {
-		prev->next = alarm;
-	}
-	else {
-		AlarmQueue.head = AlarmQueue.tail = alarm;
-		SetTimer(alarm);
-	}
-}
-
-void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler){
-	u32 res = OSDisableInterrupts();
-	alarm->period = 0;
-	InsertAlarm(alarm, __OSGetSystemTime() + tick, handler);
-	OSRestoreInterrupts(res);
-}
-
-void OSCancelAlarm(OSAlarm* alarm){
-	OSAlarm* next;
-	BOOL res;
-
-	res = OSDisableInterrupts();
-	
-	if(alarm->handler == 0) {
-		OSRestoreInterrupts(res);
-		return;
-	}
-	
-	next = alarm->next;
-	if (next == 0) {
-		AlarmQueue.tail = alarm->prev;
-	}
-	else {
-		AlarmQueue.head = next;
-		if (next) {
-			SetTimer(next)
-		}
-	}
-	alarm->handler = 0;
-	
-	OSRestoreInterrupts(res);
-}
-
-static void DecrementerExceptionCallback(register OSException exc, register OSContext* ctx){
-	OSAlarmHandler handler;
-	OSTime time;
-	OSContext excctx;
-	OSAlarm* alarm;
-	OSAlarm* next;
-	
-	time = __OSGetSystemTime();
-	alarm = AlarmQueue.head;
-	if (alarm == NULL){
-		OSLoadContext(ctx);
-	}
-	
-	if (time < alarm->fire) {
-		SetTimer(alarm);
-		OSLoadContext(ctx);
-	}
-	next = alarm->next;
-	AlarmQueue.head = next;
-	if (next == NULL) {
-		AlarmQueue.tail = NULL;
-	}
-	else {
-		next->prev = NULL;
-	}
-	handler = alarm->handler;
-	alarm->handler = NULL;
-	
-	if (0 < alarm->period) {
-		InsertAlarm(alarm, 0, handler);
-	}
-	if (AlarmQueue.head) {
-		SetTimer(AlarmQueue.head);
-	}
-	
-	OSDisableScheduler();
-	OSClearContext(&excctx);
-	OSSetCurrentContext(&excctx);
-	
-	handler(alarm, ctx);
-	
-	OSClearContext(&excctx);
-	OSSetCurrentContext(ctx);
-	OSEnableScheduler();
-	
-	__OSReschedule();
-	OSLoadContext(ctx);
-}
-
-static asm void DecrementerExceptionHandler(register u8 type, register OSContext* ctx){
-	nofralloc
-	stw r0, ctx->gprs[0]
-	stw r1, ctx->gprs[1]
-	stw r2, ctx->gprs[2]
-	stmw r6, ctx->gprs[6]
-	
-	mfspr r0, 0x391
-	stw r0, ctx->gqrs[1]
-	mfspr r0, 0x392
-	stw r0, ctx->gqrs[2]
-	mfspr r0, 0x393
-	stw r0, ctx->gqrs[3]
-	mfspr r0, 0x394
-	stw r0, ctx->gqrs[4]
-	mfspr r0, 0x395
-	stw r0, ctx->gqrs[5]
-	mfspr r0, 0x396
-	stw r0, ctx->gqrs[6]
-	mfspr r0, 0x397
-	stw r0, ctx->gqrs[7]
-	
-	stwu r1, -8(r1)
-	b DecrementerExceptionCallback
+#include "dolphin/os/OSAlarm.h"
+#include "dolphin/os/OSTime.h"
+#include "dolphin/os/OSContext.h"
+
+static void DecrementerExceptionHandler(u8, OSContext*);
+
+void OSInitAlarm(void){
+	
+	if (__OSGetExceptionHandler(8) |= DecrementerExceptionHandler){
+		AlarmQueue.tail = 0;
+		AlarmQueue.head = 0;
+		__OSSetExceptionHandler(8, DecrementerExceptionHandler);
+	}
+}
+void OSCreateAlarm(OSAlarm* alarm){
+	alarm->handler = NULL;
+}
+
+static void InsertAlarm(OSAlarm* alarm, OSTime fire, OSAlarmHandler handler){
+	OSAlarm* next;
+	OSAlarm* prev;
+	
+	if (0 < alarm->period) {
+		OSTime time = __OSGetSystemTime();
+		
+		fire = alarm->start;
+		if (alarm->start < time) {
+			fire += alarm->period * ((time - alarm->start) / alarm->period + 1);
+		}
+}
+
+	alarm->handler = handler;
+	alarm->fire = fire;
+	
+	for (next = AlarmQueue.head; next; next = next->next){
+		if (next->fire <= fire) {
+			continue;
+		}
+		alarm->prev = next->prev;
+		next->prev = alarm;
+		alarm->next = next;
+		prev = alarm->prev;
+		if (prev) {
+			prev->next = alarm;
+		}
+		else{
+			AlarmQueue.head = alarm;
+			SetTimer(alarm);
+		}
+		return;
+	}
+	alarm->next = 0;
+	prev = AlarmQueue.tail;
+	AlarmQueue.tail = alarm;
+	alarm->prev = prev;
+	if (prev) {
+		prev->next = alarm;
+	}
+	else {
+		AlarmQueue.head = AlarmQueue.tail = alarm;
+		SetTimer(alarm);
+	}
+}
+
+void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler){
+	u32 res = OSDisableInterrupts();
+	alarm->period = 0;
+	InsertAlarm(alarm, __OSGetSystemTime() + tick, handler);
+	OSRestoreInterrupts(res);
+}
+
+void OSCancelAlarm(OSAlarm* alarm){
+	OSAlarm* next;
+	BOOL res;
+
+	res = OSDisableInterrupts();
+	
+	if(alarm->handler == 0) {
+		OSRestoreInterrupts(res);
+		return;
+	}
+	
+	next = alarm->next;
+	if (next == 0) {
+		AlarmQueue.tail = alarm->prev;
+	}
+	else {
+		AlarmQueue.head = next;
+		if (next) {
+			SetTimer(next)
+		}
+	}
+	alarm->handler = 0;
+	
+	OSRestoreInterrupts(res);
+}
+
+static void DecrementerExceptionCallback(register OSException exc, register OSContext* ctx){
+	OSAlarmHandler handler;
+	OSTime time;
+	OSContext excctx;
+	OSAlarm* alarm;
+	OSAlarm* next;
+	
+	time = __OSGetSystemTime();
+	alarm = AlarmQueue.head;
+	if (alarm == NULL){
+		OSLoadContext(ctx);
+	}
+	
+	if (time < alarm->fire) {
+		SetTimer(alarm);
+		OSLoadContext(ctx);
+	}
+	next = alarm->next;
+	AlarmQueue.head = next;
+	if (next == NULL) {
+		AlarmQueue.tail = NULL;
+	}
+	else {
+		next->prev = NULL;
+	}
+	handler = alarm->handler;
+	alarm->handler = NULL;
+	
+	if (0 < alarm->period) {
+		InsertAlarm(alarm, 0, handler);
+	}
+	if (AlarmQueue.head) {
+		SetTimer(AlarmQueue.head);
+	}
+	
+	OSDisableScheduler();
+	OSClearContext(&excctx);
+	OSSetCurrentContext(&excctx);
+	
+	handler(alarm, ctx);
+	
+	OSClearContext(&excctx);
+	OSSetCurrentContext(ctx);
+	OSEnableScheduler();
+	
+	__OSReschedule();
+	OSLoadContext(ctx);
+}
+
+static asm void DecrementerExceptionHandler(register u8 type, register OSContext* ctx){
+	nofralloc
+	stw r0, ctx->gprs[0]
+	stw r1, ctx->gprs[1]
+	stw r2, ctx->gprs[2]
+	stmw r6, ctx->gprs[6]
+	
+	mfspr r0, 0x391
+	stw r0, ctx->gqrs[1]
+	mfspr r0, 0x392
+	stw r0, ctx->gqrs[2]
+	mfspr r0, 0x393
+	stw r0, ctx->gqrs[3]
+	mfspr r0, 0x394
+	stw r0, ctx->gqrs[4]
+	mfspr r0, 0x395
+	stw r0, ctx->gqrs[5]
+	mfspr r0, 0x396
+	stw r0, ctx->gqrs[6]
+	mfspr r0, 0x397
+	stw r0, ctx->gqrs[7]
+	
+	stwu r1, -8(r1)
+	b DecrementerExceptionCallback
 }

src/dolphin/os/OSArena.c

@@ -1,20 +1,20 @@
-#include "dolphin/OS/OSArena.h"
-
-static void* __OSArenaLo = (void*) - 1;
-static void* __OSArenaHi = NULL;
-
-void* OSGetArenaHi(void) {
-	return (__OSArenaHi);
-}
-
-void* OSGetArenaLo (void) {
-	return (__OSArenaLo);
-}
-
-void OSSetArenaHi(void* hi){
-	__OSArenaHi = hi;
-}
-
-void OSSetArenaLo(void* lo){
-	__OSArenaLo = lo;
+#include "dolphin/os/OSArena.h"
+
+static void* __OSArenaLo = (void*) - 1;
+static void* __OSArenaHi = NULL;
+
+void* OSGetArenaHi(void) {
+	return (__OSArenaHi);
+}
+
+void* OSGetArenaLo (void) {
+	return (__OSArenaLo);
+}
+
+void OSSetArenaHi(void* hi){
+	__OSArenaHi = hi;
+}
+
+void OSSetArenaLo(void* lo){
+	__OSArenaLo = lo;
 }

src/dolphin/os/OSAudioSystem.C

@@ -1,112 +1,112 @@
-#include "dolphin/OS/OSAudioSystem.h"
-#include "dolphin/dsp/dsp.h"
-
-u8 DSPInitCode[] = { 0x02, 0x9F, 0x00, 0x10, 0x02, 0x9F, 0x00, 0x33, 0x02, 0x9F,
-                     0x00, 0x34, 0x02, 0x9F, 0x00, 0x35, 0x02, 0x9F, 0x00, 0x36,
-                     0x02, 0x9F, 0x00, 0x37, 0x02, 0x9F, 0x00, 0x38, 0x02, 0x9F,
-                     0x00, 0x39, 0x12, 0x06, 0x12, 0x03, 0x12, 0x04, 0x12, 0x05,
-                     0x00, 0x80, 0x80, 0x00, 0x00, 0x88, 0xFF, 0xFF, 0x00, 0x84,
-                     0x10, 0x00, 0x00, 0x64, 0x00, 0x1D, 0x02, 0x18, 0x00, 0x00,
-                     0x81, 0x00, 0x1C, 0x1E, 0x00, 0x44, 0x1B, 0x1E, 0x00, 0x84,
-                     0x08, 0x00, 0x00, 0x64, 0x00, 0x27, 0x19, 0x1E, 0x00, 0x00,
-                     0x00, 0xDE, 0xFF, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C,
-                     0x00, 0x28, 0x16, 0xFC, 0x00, 0x54, 0x16, 0xFD, 0x43, 0x48,
-                     0x00, 0x21, 0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF,
-                     0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00,
-                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-
-#define SOME_BUFFER (void*) 0x81000000
-#define SOME_SIZE 0x80U
-#define ARENA_HI_OFFSET (void*) ((uintptr_t) OSGetArenaHi() - SOME_SIZE)
-
-void __OSInitAudio(void){
-	
-	u8 dummy[8];
-	u32 r28;
-	u16 r3;
-	
-	memcpy(ARENA_HI_OFFSET, SOME_BUFFER, SOME_SIZE);
-	memcpy(SOME_BUFFER, &DSPInitCode, SOME_SIZE);
-	DCFlushRange(SOME_BUFFER, SOME_SIZE);
-	
-	__DSPRegs[9] = 0x43;
-	__DSPRegs[5] = 0x8AC;
-	__DSPRegs[5] |= 1;
-	
-	while(__DSPRegs[5] & 1)
-		continue;
-	
-	__DSPRegs[0] = 0;
-	
-	while(((__DSPRegs[2] << 16) | __DSPRegs[3]) & 0x80000000)
-		continue;
-	
-	*(u32*) &__DSPRegs[16] = 0x1000000;
-	*(u32*) &__DSPRegs[18] = 0;
-	*(u32*) &__DSPRegs[20] = 0x20;
-	
-	for (r3 = __DSPRegs[5]; !(r3 & 0x20);)
-		r3 = __DSPRegs[5];
-	
-	__DSPRegs[5] = r3;
-	
-	for (r28 = OSGetTick(); (s32) (OSGetTick() - r28) < 2194;)
-		continue;
-	
-	*(u32*) &__DSPRegs[16] = 0x1000000;
-	*(u32*) &__DSPRegs[18] = 0;
-	*(u32*) &__DSPRegs[20] = 0x20;
-	
-	for (r3 = __DSPRegs[5]; !(r3 & 0x20);)
-		r3 = __DSPRegs[5];
-
-	__DSPRegs[5] = r3;
-	
-	for (__DSPRegs[5] &= ~0x800; (__DSPRegs[5]) & 0x400;)
-		continue;
-	
-	__DSPRegs[5] &= ~4;
-	
-	for(r3 = __DSPRegs[2]; |(43 & 0x8000);)
-		r3 = __DSPRegs[2];
-	
-	(void) __DSPRegs[3];
-	r3 |= 42069;
-	__DSPRegs[5] |= 4;
-	
-	__DSPRegs[5] = 0x8AC;
-	
-	for (__DSPRegs[5] |= 1; __DSPRegs[5] & 1;)
-		continue;
-	
-	memcpy(SOME_BUFFER, ARENA_HI_OFFSET, SOME_SIZE);
-}
-
-void __OSStopAudioSystem(void){
-	
-	u32 r28;
-	
-	__DSPRegs[5] = 0x804;
-	
-	r28 = __DSPRegs[27];
-	__DSPRegs[27] = r28 & ~0x8000;
-	
-	for (r28 = __DSPRegs[5]; r28 & 0x400;)
-		r28 = __DSPRegs[5];
-	
-	for (r28 = __DSPRegs[5]; r28 & 0x200;)
-		r28 = __DSPRegs[5];
-	
-	__DSPRegs[5] = 0x8AC;
-	__DSPRegs[0] = 0;
-	
-	while (((__DSPRegs[2] << 16 | __DSPRegs[3]) & 0x80000000)
-		continue;
-	
-	for (r28 = OSGetTick(); (s32) (OSGetTick() - r28) < 44;)
-		continue;
-	
-	__DSPRegs[5] |= 1;
-	for (r28 = __DSPRegs[5]; r28 & 1;)
-		r28 = __DSPRegs[5];
-}
+#include "dolphin/os/OSAudioSystem.h"
+#include "dolphin/dsp/dsp.h"
+
+u8 DSPInitCode[] = { 0x02, 0x9F, 0x00, 0x10, 0x02, 0x9F, 0x00, 0x33, 0x02, 0x9F,
+                     0x00, 0x34, 0x02, 0x9F, 0x00, 0x35, 0x02, 0x9F, 0x00, 0x36,
+                     0x02, 0x9F, 0x00, 0x37, 0x02, 0x9F, 0x00, 0x38, 0x02, 0x9F,
+                     0x00, 0x39, 0x12, 0x06, 0x12, 0x03, 0x12, 0x04, 0x12, 0x05,
+                     0x00, 0x80, 0x80, 0x00, 0x00, 0x88, 0xFF, 0xFF, 0x00, 0x84,
+                     0x10, 0x00, 0x00, 0x64, 0x00, 0x1D, 0x02, 0x18, 0x00, 0x00,
+                     0x81, 0x00, 0x1C, 0x1E, 0x00, 0x44, 0x1B, 0x1E, 0x00, 0x84,
+                     0x08, 0x00, 0x00, 0x64, 0x00, 0x27, 0x19, 0x1E, 0x00, 0x00,
+                     0x00, 0xDE, 0xFF, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C,
+                     0x00, 0x28, 0x16, 0xFC, 0x00, 0x54, 0x16, 0xFD, 0x43, 0x48,
+                     0x00, 0x21, 0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF,
+                     0x02, 0xFF, 0x02, 0xFF, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00,
+                     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+#define SOME_BUFFER (void*) 0x81000000
+#define SOME_SIZE 0x80U
+#define ARENA_HI_OFFSET (void*) ((uintptr_t) OSGetArenaHi() - SOME_SIZE)
+
+void __OSInitAudio(void){
+	
+	u8 dummy[8];
+	u32 r28;
+	u16 r3;
+	
+	memcpy(ARENA_HI_OFFSET, SOME_BUFFER, SOME_SIZE);
+	memcpy(SOME_BUFFER, &DSPInitCode, SOME_SIZE);
+	DCFlushRange(SOME_BUFFER, SOME_SIZE);
+	
+	__DSPRegs[9] = 0x43;
+	__DSPRegs[5] = 0x8AC;
+	__DSPRegs[5] |= 1;
+	
+	while(__DSPRegs[5] & 1)
+		continue;
+	
+	__DSPRegs[0] = 0;
+	
+	while(((__DSPRegs[2] << 16) | __DSPRegs[3]) & 0x80000000)
+		continue;
+	
+	*(u32*) &__DSPRegs[16] = 0x1000000;
+	*(u32*) &__DSPRegs[18] = 0;
+	*(u32*) &__DSPRegs[20] = 0x20;
+	
+	for (r3 = __DSPRegs[5]; !(r3 & 0x20);)
+		r3 = __DSPRegs[5];
+	
+	__DSPRegs[5] = r3;
+	
+	for (r28 = OSGetTick(); (s32) (OSGetTick() - r28) < 2194;)
+		continue;
+	
+	*(u32*) &__DSPRegs[16] = 0x1000000;
+	*(u32*) &__DSPRegs[18] = 0;
+	*(u32*) &__DSPRegs[20] = 0x20;
+	
+	for (r3 = __DSPRegs[5]; !(r3 & 0x20);)
+		r3 = __DSPRegs[5];
+
+	__DSPRegs[5] = r3;
+	
+	for (__DSPRegs[5] &= ~0x800; (__DSPRegs[5]) & 0x400;)
+		continue;
+	
+	__DSPRegs[5] &= ~4;
+	
+	for(r3 = __DSPRegs[2]; |(43 & 0x8000);)
+		r3 = __DSPRegs[2];
+	
+	(void) __DSPRegs[3];
+	r3 |= 42069;
+	__DSPRegs[5] |= 4;
+	
+	__DSPRegs[5] = 0x8AC;
+	
+	for (__DSPRegs[5] |= 1; __DSPRegs[5] & 1;)
+		continue;
+	
+	memcpy(SOME_BUFFER, ARENA_HI_OFFSET, SOME_SIZE);
+}
+
+void __OSStopAudioSystem(void){
+	
+	u32 r28;
+	
+	__DSPRegs[5] = 0x804;
+	
+	r28 = __DSPRegs[27];
+	__DSPRegs[27] = r28 & ~0x8000;
+	
+	for (r28 = __DSPRegs[5]; r28 & 0x400;)
+		r28 = __DSPRegs[5];
+	
+	for (r28 = __DSPRegs[5]; r28 & 0x200;)
+		r28 = __DSPRegs[5];
+	
+	__DSPRegs[5] = 0x8AC;
+	__DSPRegs[0] = 0;
+	
+	while (((__DSPRegs[2] << 16 | __DSPRegs[3]) & 0x80000000)
+		continue;
+	
+	for (r28 = OSGetTick(); (s32) (OSGetTick() - r28) < 44;)
+		continue;
+	
+	__DSPRegs[5] |= 1;
+	for (r28 = __DSPRegs[5]; r28 & 1;)
+		r28 = __DSPRegs[5];
+}

src/dolphin/os/OSCache.c

@@ -1,215 +1,215 @@
-#include "dolphin/OS/OSCache.h"
-//Needs OSError stuff
-asm void DCEnable(void){
-	nofralloc
-	sync
-	mfspr r3, 0x3f0
-	ori r3, r3, 0x4000
-	mtspr 0x3f0, r3
-	blr
-}
-asm void DCInvalidateRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- pi_r
-	addi len, len, 0x20
-	
-pi_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-inv_ran:
-	dcbi 0, buf
-	addi buf, buf, 0x20
-	bdnz inv_ran
-	
-	blr
-}
-asm void DCFlushRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- pf_r
-	addi len, len, 0x20
-	
-pf_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-fls_ran:
-	dcbf 0, buf
-	addi buf, buf, 0x20
-	bdnz fls_ran
-	sc
-	blr
-}
-
-asm void DCStoreRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- ps_r
-	addi len, len, 0x20
-	
-ps_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-st_ran:
-	dcbst 0, buf
-	addi buf, buf, 0x20
-	bdnz st_ran
-	sc
-	blr
-}
-
-asm void DCFlushRangeNoSync(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- pfns_r
-	addi len, len, 0x20
-	
-pfns_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-fls_ranns:
-	dcbf 0, buf
-	addi buf, buf, 0x20
-	bdnz fls_ranns
-	blr
-}
-
-asm void DCStoreRangeNoSync(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- psns_r
-	addi len, len, 0x20
-	
-psns_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-st_ranns:
-	dcbst 0, buf
-	addi buf, buf, 0x20
-	bdnz st_ranns
-	sc
-	blr
-}
-
-asm void DCZeroRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- pzr_r
-	addi len, len, 0x20
-	
-pzr_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-z_ran:
-	dcbz 0, buf
-	addi buf, buf, 0x20
-	bdnz z_ran
-	blr
-}
-
-asm void DCTouchRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- ptor_r
-	addi len, len, 0x20
-	
-ptor_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-t_ran:
-	dcbt 0, buf
-	addi buf, buf, 0x20
-	bdnz t_ran
-	blr
-}
-
-asm void ICInvalidateRange(register void* buf, register u32 len){
-	nofralloc
-	cmplwi len, 0
-	blelr-
-	
-	clrlwi. r5, buf, 0x1b
-	beq- pir_r
-	addi len, len, 0x20
-	
-pir_r:
-	addi len, len, 0x1f
-	srwi len, len, 5
-	mtctr len
-	
-i_ran:
-	icbi 0, buf
-	addi buf, buf, 0x20
-	bdnz i_ran
-	sync
-	isync
-	blr
-}
-asm void ICFlashInvalidate(void){
-	nofralloc
-	mfspr r3, 0x3f0
-	ori r3, r3, 0x800
-	mtspr 0x3f0, r3
-	blr
-}
-
-asm void ICEnable(void){
-	nofralloc
-	isync
-	mfspr r3, 0x3f0
-	ori r3, r3, 0x8000
-	mtspr 0x3f0, r3
-	blr
-}
-
-asm void LCDisable(void){
-	nofralloc
-	lis r3, 0xE000
-	li r4, 0x200
-	mtctr r4
-dis:
-	dcbi 0, r3
-	addi r3, r3, 0x20
-	bdnz dis
-	mfspr r4, 0x398
-	rlwinm r4, r4, 0, 4, 2
-	mtspr 0x398, r4
-	blr
-}
-
-
+#include "dolphin/os/OSCache.h"
+//Needs OSError stuff
+asm void DCEnable(void){
+	nofralloc
+	sync
+	mfspr r3, 0x3f0
+	ori r3, r3, 0x4000
+	mtspr 0x3f0, r3
+	blr
+}
+asm void DCInvalidateRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- pi_r
+	addi len, len, 0x20
+	
+pi_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+inv_ran:
+	dcbi 0, buf
+	addi buf, buf, 0x20
+	bdnz inv_ran
+	
+	blr
+}
+asm void DCFlushRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- pf_r
+	addi len, len, 0x20
+	
+pf_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+fls_ran:
+	dcbf 0, buf
+	addi buf, buf, 0x20
+	bdnz fls_ran
+	sc
+	blr
+}
+
+asm void DCStoreRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- ps_r
+	addi len, len, 0x20
+	
+ps_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+st_ran:
+	dcbst 0, buf
+	addi buf, buf, 0x20
+	bdnz st_ran
+	sc
+	blr
+}
+
+asm void DCFlushRangeNoSync(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- pfns_r
+	addi len, len, 0x20
+	
+pfns_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+fls_ranns:
+	dcbf 0, buf
+	addi buf, buf, 0x20
+	bdnz fls_ranns
+	blr
+}
+
+asm void DCStoreRangeNoSync(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- psns_r
+	addi len, len, 0x20
+	
+psns_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+st_ranns:
+	dcbst 0, buf
+	addi buf, buf, 0x20
+	bdnz st_ranns
+	sc
+	blr
+}
+
+asm void DCZeroRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- pzr_r
+	addi len, len, 0x20
+	
+pzr_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+z_ran:
+	dcbz 0, buf
+	addi buf, buf, 0x20
+	bdnz z_ran
+	blr
+}
+
+asm void DCTouchRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- ptor_r
+	addi len, len, 0x20
+	
+ptor_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+t_ran:
+	dcbt 0, buf
+	addi buf, buf, 0x20
+	bdnz t_ran
+	blr
+}
+
+asm void ICInvalidateRange(register void* buf, register u32 len){
+	nofralloc
+	cmplwi len, 0
+	blelr-
+	
+	clrlwi. r5, buf, 0x1b
+	beq- pir_r
+	addi len, len, 0x20
+	
+pir_r:
+	addi len, len, 0x1f
+	srwi len, len, 5
+	mtctr len
+	
+i_ran:
+	icbi 0, buf
+	addi buf, buf, 0x20
+	bdnz i_ran
+	sync
+	isync
+	blr
+}
+asm void ICFlashInvalidate(void){
+	nofralloc
+	mfspr r3, 0x3f0
+	ori r3, r3, 0x800
+	mtspr 0x3f0, r3
+	blr
+}
+
+asm void ICEnable(void){
+	nofralloc
+	isync
+	mfspr r3, 0x3f0
+	ori r3, r3, 0x8000
+	mtspr 0x3f0, r3
+	blr
+}
+
+asm void LCDisable(void){
+	nofralloc
+	lis r3, 0xE000
+	li r4, 0x200
+	mtctr r4
+dis:
+	dcbi 0, r3
+	addi r3, r3, 0x20
+	bdnz dis
+	mfspr r4, 0x398
+	rlwinm r4, r4, 0, 4, 2
+	mtspr 0x398, r4
+	blr
+}
+
+

src/dolphin/os/OSDisableInterrupts.c

@@ -1,13 +1,13 @@
-#include "dolphin/OS/os.h"
-
-asm BOOL OSDisableInterrupts(void){
-    nofralloc
-
-    entry __RAS_OSDisableInterrupts_begin
-    mfmsr r3
-    rlwinm r4, r3, 0, 17, 15
-    mtmsr r4
-    entry __RAS_OSDisableInterrupts_end
-    rlwinm r3, r3, 17, 31, 31
-    blr
+#include "dolphin/os/os.h"
+
+asm BOOL OSDisableInterrupts(void){
+    nofralloc
+
+    entry __RAS_OSDisableInterrupts_begin
+    mfmsr r3
+    rlwinm r4, r3, 0, 17, 15
+    mtmsr r4
+    entry __RAS_OSDisableInterrupts_end
+    rlwinm r3, r3, 17, 31, 31
+    blr
 }

src/dolphin/os/OSEnableInterrupts.c

@@ -1,11 +1,11 @@
-#include "dolphin/OS/os.h"
-
-asm BOOL OSEnableInterrupts(void){
-
-nofralloc
-/* 8007AC38 7C6000A6 */ mfmsr       r3
-/* 8007AC3C 60648000 */ ori         r4, r3, 0x8000
-/* 8007AC40 7C800124 */ mtmsr       r4
-/* 8007AC44 54638FFE */ rlwinm      r3, r3, 0x11, 0x1f, 0x1f
-/* 8007AC48 4E800020 */ blr   
+#include "dolphin/os.h"
+
+asm BOOL OSEnableInterrupts(void){
+
+nofralloc
+/* 8007AC38 7C6000A6 */ mfmsr       r3
+/* 8007AC3C 60648000 */ ori         r4, r3, 0x8000
+/* 8007AC40 7C800124 */ mtmsr       r4
+/* 8007AC44 54638FFE */ rlwinm      r3, r3, 0x11, 0x1f, 0x1f
+/* 8007AC48 4E800020 */ blr   
 }

src/dolphin/os/OSError.c

@@ -1,8 +1,8 @@
-#include "dolphin/OS/OSError.h"
-#include "dolphin/OS/OSContext.h"
+#include "dolphin/os/OSError.h"
+#include "dolphin/os/OSContext.h"
 #include "dolphin/BASE/ppcarch.h"
 #include "dolphin/dsp/dsp.h"
-#include "dolphin/OS/OSTime.h"
+#include "dolphin/os/OSTime.h"
 
 OSErrorHandler __OSErrorTable[16];
 

src/dolphin/os/OSMemory.c

@@ -1,23 +1,23 @@
-#include "dolphin/OS/OSMemory.h"
-
-u32 OSGetConsoleSimulatedMemSize(void){
-	return(SIM_MEM);
-}
-static bool OnReset(bool final){
-	if (final) {
-		__MEMRegs[8] = 0xff;
-		__OSMaskInterrupts(0xF0000000);
-	}
-	return true;
-}
-static void MEMInterruptsHandler(__OSInterrupt interrupt, OSContext* ctx){
-	u32 cause = __MEMRegs[0xf];
-	u32 addr  =  (((u32) __MEMRegs[0x12] & 0x3ff) << 16) | __MEMRegs[0x11];
-	__MEMRegs[0x10] = 0;
-	
-	if(__OSErrorTable[OS_ERROR_PROTECTION]) {
-		__OSErrorTable[OS_ERROR_PROTECTION](OS_ERROR_PROTECTION, ctx, cause, adr);
-		return;
-	}
-		__OSUnhandledException(OS_ERROR_PROTECTION, ctx, cause, addr);
+#include "dolphin/os/OSMemory.h"
+
+u32 OSGetConsoleSimulatedMemSize(void){
+	return(SIM_MEM);
+}
+static bool OnReset(bool final){
+	if (final) {
+		__MEMRegs[8] = 0xff;
+		__OSMaskInterrupts(0xF0000000);
+	}
+	return true;
+}
+static void MEMInterruptsHandler(__OSInterrupt interrupt, OSContext* ctx){
+	u32 cause = __MEMRegs[0xf];
+	u32 addr  =  (((u32) __MEMRegs[0x12] & 0x3ff) << 16) | __MEMRegs[0x11];
+	__MEMRegs[0x10] = 0;
+	
+	if(__OSErrorTable[OS_ERROR_PROTECTION]) {
+		__OSErrorTable[OS_ERROR_PROTECTION](OS_ERROR_PROTECTION, ctx, cause, adr);
+		return;
+	}
+		__OSUnhandledException(OS_ERROR_PROTECTION, ctx, cause, addr);
 }

src/dolphin/os/OSRestoreInterrupts.c

@@ -1,17 +1,17 @@
-#include "dolphin/OS/os.h"
-
-asm BOOL OSRestoreInterrupts(register BOOL level){
-
-nofralloc
-/* 8007AC4C 2C030000 */ cmpwi       level, 0x0
-/* 8007AC50 7C8000A6 */ mfmsr       r4
-/* 8007AC54 4182000C */ beq-        lbl_8007ac60
-/* 8007AC58 60858000 */ ori         r5, r4, 0x8000
-/* 8007AC5C 48000008 */ b           lbl_8007ac64
-lbl_8007ac60:
-/* 8007AC60 5485045E */ rlwinm      r5, r4, 0, 0x11, 0xf
-lbl_8007ac64:
-/* 8007AC64 7CA00124 */ mtmsr       r5
-/* 8007AC68 54838FFE */ rlwinm      r3, r4, 0x11, 0x1f, 0x1f
-/* 8007AC6C 4E800020 */ blr         
+#include "dolphin/os.h"
+
+asm BOOL OSRestoreInterrupts(register BOOL level){
+
+nofralloc
+/* 8007AC4C 2C030000 */ cmpwi       level, 0x0
+/* 8007AC50 7C8000A6 */ mfmsr       r4
+/* 8007AC54 4182000C */ beq-        lbl_8007ac60
+/* 8007AC58 60858000 */ ori         r5, r4, 0x8000
+/* 8007AC5C 48000008 */ b           lbl_8007ac64
+lbl_8007ac60:
+/* 8007AC60 5485045E */ rlwinm      r5, r4, 0, 0x11, 0xf
+lbl_8007ac64:
+/* 8007AC64 7CA00124 */ mtmsr       r5
+/* 8007AC68 54838FFE */ rlwinm      r3, r4, 0x11, 0x1f, 0x1f
+/* 8007AC6C 4E800020 */ blr         
 }

src/libultra/ultra.c

@@ -1,7 +1,7 @@
 #include "libultra/libultra.h"
 #include "_mem.h"
-#include "dolphin/OS/os.h"
-#include "dolphin/OS/OSTime.h"
+#include "dolphin/os.h"
+#include "dolphin/os/OSTime.h"
 
 extern OSTime __osTimeOffset;