From 0311f06aa3a4aa0759ebcc34f5f90e6690cbbf96 Mon Sep 17 00:00:00 2001 From: SwareJonge Date: Sun, 19 Feb 2023 23:26:52 +0100 Subject: [PATCH 1/4] Add JKRHeap.cpp --- common.py | 14 + config/dol_slices.yml | 5 + config/symbols.yml | 18 +- configure.py | 3 + include/JSystem/JKernel/JKRDisposer.h | 21 ++ include/JSystem/JKernel/JKRHeap.h | 288 +++++++++++++++++ include/JSystem/JSupport/JSUList.h | 223 ++++++++++++++ include/JSystem/JUT/JUTAssertion.h | 25 +- include/dolphin/OS/OSAddress.h | 32 ++ include/dolphin/OS/OSAlloc.h | 15 + include/dolphin/OS/OSMutex.h | 36 +++ include/dolphin/OS/OSThread.h | 129 ++++++++ include/dolphin/OS/OSUtil.h | 18 ++ include/dolphin/OS/os.h | 5 +- src/JSystem/JKernel/JKRHeap.cpp | 426 ++++++++++++++++++++++++++ 15 files changed, 1255 insertions(+), 3 deletions(-) create mode 100644 include/JSystem/JKernel/JKRDisposer.h create mode 100644 include/JSystem/JKernel/JKRHeap.h create mode 100644 include/JSystem/JSupport/JSUList.h create mode 100644 include/dolphin/OS/OSAddress.h create mode 100644 include/dolphin/OS/OSAlloc.h create mode 100644 include/dolphin/OS/OSMutex.h create mode 100644 include/dolphin/OS/OSThread.h create mode 100644 include/dolphin/OS/OSUtil.h create mode 100644 src/JSystem/JKernel/JKRHeap.cpp diff --git a/common.py b/common.py index 383582fd..cbe130aa 100644 --- a/common.py +++ b/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) diff --git a/config/dol_slices.yml b/config/dol_slices.yml index 2e1c13fa..ef5224dd 100644 --- a/config/dol_slices.yml +++ b/config/dol_slices.yml @@ -4,6 +4,11 @@ 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: diff --git a/config/symbols.yml b/config/symbols.yml index b1abad27..b3cbc146 100644 --- a/config/symbols.yml +++ b/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 diff --git a/configure.py b/configure.py index c96b5b34..7da3cae4 100644 --- a/configure.py +++ b/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 diff --git a/include/JSystem/JKernel/JKRDisposer.h b/include/JSystem/JKernel/JKRDisposer.h new file mode 100644 index 00000000..9a4ced98 --- /dev/null +++ b/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 mPointerLinks; // _8 +}; + +#endif \ No newline at end of file diff --git a/include/JSystem/JKernel/JKRHeap.h b/include/JSystem/JKernel/JKRHeap.h new file mode 100644 index 00000000..4d75f54d --- /dev/null +++ b/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 mChildTree; + /* 0x5C */ JSUList 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 diff --git a/include/JSystem/JSupport/JSUList.h b/include/JSystem/JSupport/JSUList.h new file mode 100644 index 00000000..0dcf2ab1 --- /dev/null +++ b/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 JSULink; // friend class? i'm C++ noob + +template +class JSUList : public JSUPtrList +{ +public: + JSUList(bool thing) : JSUPtrList(thing) + { + } + JSUList() : JSUPtrList() + { + } + + bool append(JSULink *link) { return JSUPtrList::append((JSUPtrLink *)link); } + bool prepend(JSULink *link) { return JSUPtrList::prepend((JSUPtrLink *)link); } + bool insert(JSULink *before, JSULink *link) { return JSUPtrList::insert((JSUPtrLink *)before, (JSUPtrLink *)link); } + bool remove(JSULink *link) { return JSUPtrList::remove((JSUPtrLink *)link); } + + JSULink *getFirst() const { return (JSULink *)getFirstLink(); } + JSULink *getLast() const { return (JSULink *)getLastLink(); } + JSULink *getEnd() const { return nullptr; } + + u32 getNumLinks() const { return mLinkCount; } +}; + +template +class JSUListIterator +{ +public: + JSUListIterator() + : mLink(nullptr) + { + } + JSUListIterator(JSULink *link) + : mLink(link) + { + } + JSUListIterator(JSUList *list) + : mLink(list->getFirst()) + { + } + + JSUListIterator &operator=(JSULink *link) + { + this->mLink = link; + return *this; + } + + T *getObject() { return this->mLink->getObject(); } + + bool operator==(JSULink const *other) const { return this->mLink == other; } + bool operator!=(JSULink const *other) const { return this->mLink != other; } + bool operator==(JSUListIterator const &other) const { return this->mLink == other.mLink; } + bool operator!=(JSUListIterator const &other) const { return this->mLink != other.mLink; } + + JSUListIterator operator++(int) + { + JSUListIterator prev = *this; + this->mLink = this->mLink->getNext(); + return prev; + } + + JSUListIterator &operator++() + { + this->mLink = this->mLink->getNext(); + return *this; + } + + JSUListIterator operator--(int) + { + JSUListIterator prev = *this; + this->mLink = this->mLink->getPrev(); + return prev; + } + + JSUListIterator &operator--() + { + this->mLink = this->mLink->getPrev(); + return *this; + } + + T &operator*() { return *this->getObject(); } + + T *operator->() { return this->getObject(); } + + // private: + JSULink *mLink; +}; + +template +class JSULink : public JSUPtrLink +{ +public: + JSULink(void *pData) : JSUPtrLink(pData) + { + } + + T *getObject() const { return (T *)mData; } + JSUList *getList() const { return (JSUList *)JSUPtrLink::getList(); } // fabricated, offcial name: getSupervisor + JSULink *getNext() const { return (JSULink *)JSUPtrLink::getNext(); } + JSULink *getPrev() const { return (JSULink *)JSUPtrLink::getPrev(); } + + ~JSULink() + { + } +}; + +template // TODO: most of these inlines are probably wrong: rework +class JSUTree : public JSUList, public JSULink +{ +public: + JSUTree(T *owner) : JSUList(), JSULink(owner) {} + ~JSUTree() {} + + bool appendChild(JSUTree *child) { return this->append(child); } + bool prependChild(JSUTree *child) { return this->prepend(child); } + bool removeChild(JSUTree *child) { return this->remove(child); } + bool insertChild(JSUTree *before, JSUTree *child) { return this->insert(before, child); } + + JSUTree *getEndChild() const { return nullptr; } + JSUTree *getFirstChild() const { return (JSUTree *)getFirstLink(); } + JSUTree *getLastChild() const { return (JSUTree *)this->getLast(); } + JSUTree *getNextChild() const { return (JSUTree *)mNext; } + JSUTree *getPrevChild() const { return (JSUTree *)this->getPrev(); } + u32 getNumChildren() const { return mLinkCount; } + T *getObject() const { return (T *)this->mData; } + JSUTree *getParent() const { return (JSUTree *)this->mPtrList; } +}; + +template +class JSUTreeIterator +{ +public: + JSUTreeIterator() : mTree(nullptr) {} + JSUTreeIterator(JSUTree *tree) : mTree(tree) {} + + JSUTreeIterator &operator=(JSUTree *tree) + { + this->mTree = tree; + return *this; + } + + T *getObject() const { return mTree->getObject(); } + + bool operator==(JSUTree *other) { return this->mTree == other; } + + bool operator!=(const JSUTree *other) const { return this->mTree != other; } + + JSUTreeIterator operator++(int) + { + JSUTreeIterator prev = *this; + this->mTree = this->mTree->getNextChild(); + return prev; + } + + JSUTreeIterator &operator++() + { + this->mTree = this->mTree->getNextChild(); + return *this; + } + + T &operator*() { return *this->getObject(); } + + T *operator->() const { return mTree->getObject(); } + +private: + JSUTree *mTree; +}; + +#endif /* JSULIST_H */ \ No newline at end of file diff --git a/include/JSystem/JUT/JUTAssertion.h b/include/JSystem/JUT/JUTAssertion.h index 9a3f600a..405f1c63 100644 --- a/include/JSystem/JUT/JUTAssertion.h +++ b/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 diff --git a/include/dolphin/OS/OSAddress.h b/include/dolphin/OS/OSAddress.h new file mode 100644 index 00000000..2888e45e --- /dev/null +++ b/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 \ No newline at end of file diff --git a/include/dolphin/OS/OSAlloc.h b/include/dolphin/OS/OSAlloc.h new file mode 100644 index 00000000..e413f67f --- /dev/null +++ b/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 \ No newline at end of file diff --git a/include/dolphin/OS/OSMutex.h b/include/dolphin/OS/OSMutex.h new file mode 100644 index 00000000..659ec972 --- /dev/null +++ b/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 diff --git a/include/dolphin/OS/OSThread.h b/include/dolphin/OS/OSThread.h new file mode 100644 index 00000000..19193659 --- /dev/null +++ b/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 diff --git a/include/dolphin/OS/OSUtil.h b/include/dolphin/OS/OSUtil.h new file mode 100644 index 00000000..70f5071a --- /dev/null +++ b/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 \ No newline at end of file diff --git a/include/dolphin/OS/os.h b/include/dolphin/OS/os.h index 37ce2b6b..1e1ccde1 100644 --- a/include/dolphin/OS/os.h +++ b/include/dolphin/OS/os.h @@ -8,14 +8,17 @@ 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); diff --git a/src/JSystem/JKernel/JKRHeap.cpp b/src/JSystem/JKernel/JKRHeap.cpp new file mode 100644 index 00000000..bf96d780 --- /dev/null +++ b/src/JSystem/JKernel/JKRHeap.cpp @@ -0,0 +1,426 @@ +#include "JSystem/JUT/JUTAssertion.h" +#include "JSystem/JKernel/JKRHeap.h" +#include "dolphin/OS/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 *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 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 iterator(mChildTree.getFirstChild()); iterator != mChildTree.getEndChild(); ++iterator) + { + JKRHeap *result = iterator->find(memory); + if (result) + { + return result; + } + } + } + return const_cast(this); + } + return nullptr; +} + +JKRHeap *JKRHeap::findAllHeap(void *memory) const +{ + if (mChildTree.getNumChildren() != 0) + { + for (JSUTreeIterator iterator(mChildTree.getFirstChild()); iterator != mChildTree.getEndChild(); ++iterator) + { + JKRHeap *result = iterator->findAllHeap(memory); + if (result) + { + return result; + } + } + } + + if (mStart <= memory && memory < mEnd) + { + return const_cast(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 last_iterator; + JSUListIterator next_iterator; + JSUListIterator 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 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 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()); +} From 4f8cd441d4a519ebcd97756e03ca4d09c80ff806 Mon Sep 17 00:00:00 2001 From: SwareJonge Date: Mon, 20 Feb 2023 09:10:53 +0100 Subject: [PATCH 2/4] rename part1 --- include/JSystem/JKernel/JKRHeap.h | 2 +- include/dolphin/{OS => }/os.h | 62 +- include/dolphin/{OS => os2}/OSAddress.h | 0 include/dolphin/{OS => os2}/OSAlloc.h | 0 include/dolphin/{OS => os2}/OSArena.h | 34 +- include/dolphin/{OS => os2}/OSCache.h | 60 +- include/dolphin/{OS => os2}/OSContext.h | 90 +- include/dolphin/{OS => os2}/OSError.h | 0 include/dolphin/{OS => os2}/OSMemory.h | 32 +- include/dolphin/{OS => os2}/OSMutex.h | 2 +- include/dolphin/{OS => os2}/OSThread.h | 0 include/dolphin/{OS => os2}/OSTime.h | 26 +- include/dolphin/{OS => os2}/OSUtil.h | 0 include/libforest/batconfig.h | 4 +- include/libultra/libultra.h | 4 +- include/zurumode.h | 2 +- src/JSystem/JKernel/JKRHeap.cpp | 12 +- src/dolphin/{OS => os2}/OSAlarm.c | 340 ++--- src/dolphin/{OS => os2}/OSArena.c | 38 +- src/dolphin/{OS => os2}/OSAudioSystem.C | 224 ++-- src/dolphin/{OS => os2}/OSCache.c | 430 +++---- src/dolphin/{OS => os2}/OSContext.c | 1112 ++++++++--------- src/dolphin/{OS => os2}/OSDisableInterrupts.c | 24 +- src/dolphin/{OS => os2}/OSEnableInterrupts.c | 20 +- src/dolphin/{OS => os2}/OSError.c | 6 +- src/dolphin/{OS => os2}/OSMemory.c | 44 +- src/dolphin/{OS => os2}/OSRestoreInterrupts.c | 32 +- src/libultra/ultra.c | 4 +- 28 files changed, 1302 insertions(+), 1302 deletions(-) rename include/dolphin/{OS => }/os.h (91%) rename include/dolphin/{OS => os2}/OSAddress.h (100%) rename include/dolphin/{OS => os2}/OSAlloc.h (100%) rename include/dolphin/{OS => os2}/OSArena.h (93%) rename include/dolphin/{OS => os2}/OSCache.h (95%) rename include/dolphin/{OS => os2}/OSContext.h (95%) rename include/dolphin/{OS => os2}/OSError.h (100%) rename include/dolphin/{OS => os2}/OSMemory.h (94%) rename include/dolphin/{OS => os2}/OSMutex.h (95%) rename include/dolphin/{OS => os2}/OSThread.h (100%) rename include/dolphin/{OS => os2}/OSTime.h (93%) rename include/dolphin/{OS => os2}/OSUtil.h (100%) rename src/dolphin/{OS => os2}/OSAlarm.c (92%) rename src/dolphin/{OS => os2}/OSArena.c (84%) rename src/dolphin/{OS => os2}/OSAudioSystem.C (95%) rename src/dolphin/{OS => os2}/OSCache.c (91%) rename src/dolphin/{OS => os2}/OSContext.c (95%) rename src/dolphin/{OS => os2}/OSDisableInterrupts.c (85%) rename src/dolphin/{OS => os2}/OSEnableInterrupts.c (87%) rename src/dolphin/{OS => os2}/OSError.c (94%) rename src/dolphin/{OS => os2}/OSMemory.c (91%) rename src/dolphin/{OS => os2}/OSRestoreInterrupts.c (92%) diff --git a/include/JSystem/JKernel/JKRHeap.h b/include/JSystem/JKernel/JKRHeap.h index 4d75f54d..e779757b 100644 --- a/include/JSystem/JKernel/JKRHeap.h +++ b/include/JSystem/JKernel/JKRHeap.h @@ -1,7 +1,7 @@ #ifndef JKRHEAP_H #define JKRHEAP_H -#include "dolphin/OS/OSMutex.h" +#include "dolphin/os/OSMutex.h" #include "JSystem/JKernel/JKRDisposer.h" #include "types.h" diff --git a/include/dolphin/OS/os.h b/include/dolphin/os.h similarity index 91% rename from include/dolphin/OS/os.h rename to include/dolphin/os.h index 1e1ccde1..980c0295 100644 --- a/include/dolphin/OS/os.h +++ b/include/dolphin/os.h @@ -1,31 +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 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 +#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 diff --git a/include/dolphin/OS/OSAddress.h b/include/dolphin/os2/OSAddress.h similarity index 100% rename from include/dolphin/OS/OSAddress.h rename to include/dolphin/os2/OSAddress.h diff --git a/include/dolphin/OS/OSAlloc.h b/include/dolphin/os2/OSAlloc.h similarity index 100% rename from include/dolphin/OS/OSAlloc.h rename to include/dolphin/os2/OSAlloc.h diff --git a/include/dolphin/OS/OSArena.h b/include/dolphin/os2/OSArena.h similarity index 93% rename from include/dolphin/OS/OSArena.h rename to include/dolphin/os2/OSArena.h index 72c831ec..1ece78e8 100644 --- a/include/dolphin/OS/OSArena.h +++ b/include/dolphin/os2/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 \ No newline at end of file diff --git a/include/dolphin/OS/OSCache.h b/include/dolphin/os2/OSCache.h similarity index 95% rename from include/dolphin/OS/OSCache.h rename to include/dolphin/os2/OSCache.h index 6db877f3..a5fa78a9 100644 --- a/include/dolphin/OS/OSCache.h +++ b/include/dolphin/os2/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 diff --git a/include/dolphin/OS/OSContext.h b/include/dolphin/os2/OSContext.h similarity index 95% rename from include/dolphin/OS/OSContext.h rename to include/dolphin/os2/OSContext.h index 34181d85..2d545619 100644 --- a/include/dolphin/OS/OSContext.h +++ b/include/dolphin/os2/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 diff --git a/include/dolphin/OS/OSError.h b/include/dolphin/os2/OSError.h similarity index 100% rename from include/dolphin/OS/OSError.h rename to include/dolphin/os2/OSError.h diff --git a/include/dolphin/OS/OSMemory.h b/include/dolphin/os2/OSMemory.h similarity index 94% rename from include/dolphin/OS/OSMemory.h rename to include/dolphin/os2/OSMemory.h index b6e0bd31..fd33a7fc 100644 --- a/include/dolphin/OS/OSMemory.h +++ b/include/dolphin/os2/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 \ No newline at end of file diff --git a/include/dolphin/OS/OSMutex.h b/include/dolphin/os2/OSMutex.h similarity index 95% rename from include/dolphin/OS/OSMutex.h rename to include/dolphin/os2/OSMutex.h index 659ec972..36b13c2b 100644 --- a/include/dolphin/OS/OSMutex.h +++ b/include/dolphin/os2/OSMutex.h @@ -6,7 +6,7 @@ extern "C" { #endif -#include "dolphin/OS/OSThread.h" +#include "dolphin/os/OSThread.h" struct OSMutex { diff --git a/include/dolphin/OS/OSThread.h b/include/dolphin/os2/OSThread.h similarity index 100% rename from include/dolphin/OS/OSThread.h rename to include/dolphin/os2/OSThread.h diff --git a/include/dolphin/OS/OSTime.h b/include/dolphin/os2/OSTime.h similarity index 93% rename from include/dolphin/OS/OSTime.h rename to include/dolphin/os2/OSTime.h index d48d4ca0..a57a3744 100644 --- a/include/dolphin/OS/OSTime.h +++ b/include/dolphin/os2/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 \ No newline at end of file diff --git a/include/dolphin/OS/OSUtil.h b/include/dolphin/os2/OSUtil.h similarity index 100% rename from include/dolphin/OS/OSUtil.h rename to include/dolphin/os2/OSUtil.h diff --git a/include/libforest/batconfig.h b/include/libforest/batconfig.h index 11b357d2..0c47e12f 100644 --- a/include/libforest/batconfig.h +++ b/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(); diff --git a/include/libultra/libultra.h b/include/libultra/libultra.h index 2bafaea3..9264ee58 100644 --- a/include/libultra/libultra.h +++ b/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); diff --git a/include/zurumode.h b/include/zurumode.h index 96da9d3f..09db6399 100644 --- a/include/zurumode.h +++ b/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" diff --git a/src/JSystem/JKernel/JKRHeap.cpp b/src/JSystem/JKernel/JKRHeap.cpp index bf96d780..9c9c4b80 100644 --- a/src/JSystem/JKernel/JKRHeap.cpp +++ b/src/JSystem/JKernel/JKRHeap.cpp @@ -1,11 +1,11 @@ #include "JSystem/JUT/JUTAssertion.h" #include "JSystem/JKernel/JKRHeap.h" -#include "dolphin/OS/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" +#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; diff --git a/src/dolphin/OS/OSAlarm.c b/src/dolphin/os2/OSAlarm.c similarity index 92% rename from src/dolphin/OS/OSAlarm.c rename to src/dolphin/os2/OSAlarm.c index 795435af..9bef3f42 100644 --- a/src/dolphin/OS/OSAlarm.c +++ b/src/dolphin/os2/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 } \ No newline at end of file diff --git a/src/dolphin/OS/OSArena.c b/src/dolphin/os2/OSArena.c similarity index 84% rename from src/dolphin/OS/OSArena.c rename to src/dolphin/os2/OSArena.c index 69b6dc9b..f20ceb14 100644 --- a/src/dolphin/OS/OSArena.c +++ b/src/dolphin/os2/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; } \ No newline at end of file diff --git a/src/dolphin/OS/OSAudioSystem.C b/src/dolphin/os2/OSAudioSystem.C similarity index 95% rename from src/dolphin/OS/OSAudioSystem.C rename to src/dolphin/os2/OSAudioSystem.C index 1c4bb441..42d4b34b 100644 --- a/src/dolphin/OS/OSAudioSystem.C +++ b/src/dolphin/os2/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]; +} diff --git a/src/dolphin/OS/OSCache.c b/src/dolphin/os2/OSCache.c similarity index 91% rename from src/dolphin/OS/OSCache.c rename to src/dolphin/os2/OSCache.c index 7c76dd96..0666fea2 100644 --- a/src/dolphin/OS/OSCache.c +++ b/src/dolphin/os2/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 +} + + diff --git a/src/dolphin/OS/OSContext.c b/src/dolphin/os2/OSContext.c similarity index 95% rename from src/dolphin/OS/OSContext.c rename to src/dolphin/os2/OSContext.c index 685debca..1aed9c1c 100644 --- a/src/dolphin/OS/OSContext.c +++ b/src/dolphin/os2/OSContext.c @@ -1,556 +1,556 @@ -#include "dolphin/OS/OSContext.h" -#include "dolphin/OS/OSError.h" -static asm void __OSLoadFPUContext(int unused, register OSContext* ctx){ - nofralloc - lhz r5, ctx->state - clrlwi. r5, r5, 0x1f - beq exit - - lfd f0, ctx->fpscr_temp - mtfs f0 - mfspr r5, 0x398 - rlwinm. r5, r5, 3, 0x1f, 0x1f - beq load_fprs - - psq_l f0, 0x1C8(ctx), 0, 0 - psq_l f1, 0x1D0(ctx), 0, 0 - psq_l f2, 0x1D8(ctx), 0, 0 - psq_l f3, 0x1E0(ctx), 0, 0 - psq_l f4, 0x1E8(ctx), 0, 0 - psq_l f5, 0x1F0(ctx), 0, 0 - psq_l f6, 0x1F8(ctx), 0, 0 - psq_l f7, 0x200(ctx), 0, 0 - psq_l f8, 0x208(ctx), 0, 0 - psq_l f9, 0x210(ctx), 0, 0 - psq_l f10, 0x218(ctx), 0, 0 - psq_l f11, 0x220(ctx), 0, 0 - psq_l f12, 0x228(ctx), 0, 0 - psq_l f13, 0x230(ctx), 0, 0 - psq_l f14, 0x238(ctx), 0, 0 - psq_l f15, 0x240(ctx), 0, 0 - psq_l f16, 0x248(ctx), 0, 0 - psq_l f17, 0x250(ctx), 0, 0 - psq_l f18, 0x258(ctx), 0, 0 - psq_l f19, 0x260(ctx), 0, 0 - psq_l f20, 0x268(ctx), 0, 0 - psq_l f21, 0x270(ctx), 0, 0 - psq_l f22, 0x278(ctx), 0, 0 - psq_l f23, 0x280(ctx), 0, 0 - psq_l f24, 0x288(ctx), 0, 0 - psq_l f25, 0x290(ctx), 0, 0 - psq_l f26, 0x298(ctx), 0, 0 - psq_l f27, 0x2A0(ctx), 0, 0 - psq_l f28, 0x2A8(ctx), 0, 0 - psq_l f29, 0x2B0(ctx), 0, 0 - psq_l f30, 0x2B8(ctx), 0, 0 - psq_l f31, 0x2C0(ctx), 0, 0 - -load_fprs: - lfd f0, ctx->fprs[0] - lfd f1, ctx->fprs[1] - lfd f2, ctx->fprs[2] - lfd f3, ctx->fprs[3] - lfd f4, ctx->fprs[4] - lfd f5, ctx->fprs[5] - lfd f6, ctx->fprs[6] - lfd f7, ctx->fprs[7] - lfd f8, ctx->fprs[8] - lfd f9, ctx->fprs[9] - lfd f10, ctx->fprs[10] - lfd f11, ctx->fprs[11] - lfd f12, ctx->fprs[12] - lfd f13, ctx->fprs[13] - lfd f14, ctx->fprs[14] - lfd f15, ctx->fprs[15] - lfd f16, ctx->fprs[16] - lfd f17, ctx->fprs[17] - lfd f18, ctx->fprs[18] - lfd f19, ctx->fprs[19] - lfd f20, ctx->fprs[20] - lfd f21, ctx->fprs[21] - lfd f22, ctx->fprs[22] - lfd f23, ctx->fprs[23] - lfd f24, ctx->fprs[24] - lfd f25, ctx->fprs[25] - lfd f26, ctx->fprs[26] - lfd f27, ctx->fprs[27] - lfd f28, ctx->fprs[28] - lfd f29, ctx->fprs[29] - lfd f30, ctx->fprs[30] - lfd f31, ctx->fprs[31] - -exit: - blr -} - -static asm void __OSSaveFPUContext( u32 unused, u32 unused1, register OSContext* ctx){ - nofralloc - lhz r3, ctx->state - ori r3, r3, 1 - sth r3, ctx->state - - stfd f0, ctx->fprs[0] - stfd f1, ctx->fprs[1] - stfd f2, ctx->fprs[2] - stfd f3, ctx->fprs[3] - stfd f4, ctx->fprs[4] - stfd f5, ctx->fprs[5] - stfd f6, ctx->fprs[6] - stfd f7, ctx->fprs[7] - stfd f8, ctx->fprs[8] - stfd f9, ctx->fprs[9] - stfd f10, ctx->fprs[10] - stfd f11, ctx->fprs[11] - stfd f12, ctx->fprs[12] - stfd f13, ctx->fprs[13] - stfd f14, ctx->fprs[14] - stfd f15, ctx->fprs[15] - stfd f16, ctx->fprs[16] - stfd f17, ctx->fprs[17] - stfd f18, ctx->fprs[18] - stfd f19, ctx->fprs[19] - stfd f20, ctx->fprs[20] - stfd f21, ctx->fprs[21] - stfd f22, ctx->fprs[22] - stfd f23, ctx->fprs[23] - stfd f24, ctx->fprs[24] - stfd f25, ctx->fprs[25] - stfd f26, ctx->fprs[26] - stfd f27, ctx->fprs[27] - stfd f28, ctx->fprs[28] - stfd f29, ctx->fprs[29] - stfd f30, ctx->fprs[30] - stfd f31, ctx->fprs[31] - - mffs f0 - stfd f0, ctx->fpscr_tmp - lfd f0, ctx->fprs[0] - mfspr r3, 0x398 - rlwinm. r3, r3, 3, 0x1f, 0x1f - beq exit - - psq_st f0, 0x1C8(ctx), 0, 0 - psq_st f1, 0x1D0(ctx), 0, 0 - psq_st f2, 0x1D8(ctx), 0, 0 - psq_st f3, 0x1E0(ctx), 0, 0 - psq_st f4, 0x1E8(ctx), 0, 0 - psq_st f5, 0x1F0(ctx), 0, 0 - psq_st f6, 0x1F8(ctx), 0, 0 - psq_st f7, 0x200(ctx), 0, 0 - psq_st f8, 0x208(ctx), 0, 0 - psq_st f9, 0x210(ctx), 0, 0 - psq_st f10, 0x218(ctx), 0, 0 - psq_st f11, 0x220(ctx), 0, 0 - psq_st f12, 0x228(ctx), 0, 0 - psq_st f13, 0x230(ctx), 0, 0 - psq_st f14, 0x238(ctx), 0, 0 - psq_st f15, 0x240(ctx), 0, 0 - psq_st f16, 0x248(ctx), 0, 0 - psq_st f17, 0x250(ctx), 0, 0 - psq_st f18, 0x258(ctx), 0, 0 - psq_st f19, 0x260(ctx), 0, 0 - psq_st f20, 0x268(ctx), 0, 0 - psq_st f21, 0x270(ctx), 0, 0 - psq_st f22, 0x278(ctx), 0, 0 - psq_st f23, 0x280(ctx), 0, 0 - psq_st f24, 0x288(ctx), 0, 0 - psq_st f25, 0x290(ctx), 0, 0 - psq_st f26, 0x298(ctx), 0, 0 - psq_st f27, 0x2A0(ctx), 0, 0 - psq_st f28, 0x2A8(ctx), 0, 0 - psq_st f29, 0x2B0(ctx), 0, 0 - psq_st f30, 0x2B8(ctx), 0, 0 - psq_st f31, 0x2C0(ctx), 0, 0 - -exit: - blr -} - -asm void OSSetCurrentContext(register OSContext* ctx){ - nofralloc - lis r4, 0x8000 - stw ctx, OS_GET_CURRENT_CONTEXT@l(r4) - clrlwi r5, ctx, 2 - stw r5, OS_CURRENT_CONTEXT_PHYS@l(r4) - lwz r5, OS_CURRENT_FPU_CONTEXT@l(r4) - cmpw r5, ctx - bne not_cur_fpu_ctx - - lwz r6, ctx->srr1 - ori r6, r6, 0x2000 - stw r6, ctx->srr1 - mfmsr r6 - ori r6, r6, 2 - mtmsr r6 - blr - -not_cur_fpu_ctx: - lwz r6, ctx->srr1 - rlwinm r6, r6, 0, 0x13, 0x11 - stw r6, ctx->srr1 - mfmsr r6 - rlwinm r6, r6, 0, 0x13, 0x11 - ori r6, r6, 2 - mtmsr r6 - isync - blr -} - -inline OSContext* OSGetCurrentContext(void) { - return(OS_CURRENT_CONTEXT); -} - -asm BOOL OSSaveContext(register OSContext* ctx){ - nofralloc - stmw r13, ctx->gprs[13] - mfspr r0, 0x391 - stw r3, ctx->gqrs[1] - mfspr r0, 0x392 - stw r3, ctx->gqrs[2] - mfspr r0, 0x393 - stw r3, ctx->gqrs[3] - mfpsr r0, 0x394 - stw r3, ctx->gqrs[4] - mfspr r0, 0x395 - stw r3, ctx->gqrs[5] - mfpsr r0, 0x396 - stw r3, ctx->gqrs[6] - mfspr r0, 0x397 - stw r3, ctx->gqrs[7] - - mfcr r0 - - stw r3, ctx->cr - mflr r0 - stw r3, ctx->lr - stw r3, ctx->srr0 - mfmsr r0 - - stw r3, ctx->srr1 - mfctr r0 - - stw r3, ctx->ctr - mfxer r0 - - stw r3, ctx->xer - - stw r1, ctx->gprs[1] - stw r2, ctx->gprs[2] - li r0, 1 - li r0, 0x0c(r3) - li r3, 0 - - blr -} - - asm void OSLoadContext(register OSContext* ctx){ - nofralloc - lis r4, __RAS_OSDisableInterrupts_begin@ha - lwz r6, ctx->srr0 - addi r5, r4, __RAS_OSDisableInterrupts_begin@l - cmplw r6, r5 - blt- srr0_n_i_ras - lis r4, __RAS_OSDisableInterrupts_end@ha - addi r4 ,r0 __RAS_OSDisableInterrupts_end@l - blg+ srr0_n_i_ras - stw r5, ctx->srr0 - -srr0_n_i_ras: - stw r0, ctx->gprs[0] - stw r1, ctx->gprs[1] - stw r2, ctx->gprs[2] - lhz r4, ctx->state - rlwinm. r4, r5, 0, 0x1e, 0x1e - beq- load_gprs - rlwinm. r4, r5, 0, 0x1f, 0x1d - sth r4, ctx->state - lmw r5, ctx->gprs[5] - b load_spec_gprs - -load_gprs: - lmw r4, ctx->gprs[13] - -load_spec_gprs: - lwz r4, ctx->gqrs[1] - mtspr, 0x391, r4 - lwz r4, ctx->gqrs[2] - mtspr, 0x392, r4 - lwz r4, ctx->gqrs[3] - mtspr, 0x393, r4 - lwz r4, ctx->gqrs[4] - mtspr, 0x394, r4 - lwz r4, ctx->gqrs[5] - mtspr, 0x395, r4 - lwz r4, ctx->gqrs[6] - mtspr, 0x396, r4 - lwz r4, ctx->qgrs[7] - mtspr, 0x397, r4 - - lwz r4, ctx->cr - mtcrf, 0xff, r4 - - lwz r4, ctx->lr - mtlr r4 - - lwz r4, ctx->ctr - mtctr r4 - - lwz r4, ctx->xer - mtxer r4 - mfmsr r4 - rlwinm r4, r4, 0, 0x11, 0xf - rlwinm r4, r4, 0, 0x1f, 0x1d - - mtmsr r4 - lwz r4, ctx->srr0 - mtspr 0x1a, r4 - lwz r4, ctx->srr1 - mtspr 0x1b, r4 - - lwz r4, ctx->gprs[4] - lwz r3, ctx->gprs[3] - - rfi -} - -asm void* OSGetStackPointer(void){ - nofralloc - mr r3, r1 - blr -} - -inline void OSClearContext(OSContext* ctx){ - ctx->mode = 0; - ctx->state = 0; - -if(ctx == OS_CURRENT_FPU_CONTEXT){ - OS_CURRENT_FPU_CONTEXT = NULL; -} -} - -asm void OSInitContext(register OSContext* ctx, register void* srr, register void* sp){ - nofralloc - stw srr, ctx->srr0 - stw sp, ctx->gprs[1] - - li r11, 0 - ori r11, r11, 0x9032 - stw r11, ctx->srr1 - - li r0, 0 - stw r0, ctx->cr - stw r0, ctx->xer - - stw r2, ctx->gprs[2] - stw r13, ctx->gprs[13] - - stw r0, ctx->gprs[3] - stw r0, ctx->gprs[4] - stw r0, ctx->gprs[5] - stw r0, ctx->gprs[6] - stw r0, ctx->gprs[7] - stw r0, ctx->gprs[8] - stw r0, ctx->gprs[9] - stw r0, ctx->gprs[10] - stw r0, ctx->gprs[11] - stw r0, ctx->gprs[12] - stw r0, ctx->gprs[14] - stw r0, ctx->gprs[15] - stw r0, ctx->gprs[16] - stw r0, ctx->gprs[17] - stw r0, ctx->gprs[18] - stw r0, ctx->gprs[19] - stw r0, ctx->gprs[20] - stw r0, ctx->gprs[21] - stw r0, ctx->gprs[22] - stw r0, ctx->gprs[22] - stw r0, ctx->gprs[23] - stw r0, ctx->gprs[24] - stw r0, ctx->gprs[25] - stw r0, ctx->gprs[26] - stw r0, ctx->gprs[27] - stw r0, ctx->gprs[28] - stw r0, ctx->gprs[29] - stw r0, ctx->gprs[30] - stw r0, ctx->gprs[31] - - stw r0, ctx->gqrs[0] - stw r0, ctx->gqrs[1] - stw r0, ctx->gqrs[2] - stw r0, ctx->gqrs[3] - stw r0, ctx->gqrs[4] - stw r0, ctx->gqrs[5] - stw r0, ctx->gqrs[6] - stw r0, ctx->gqrs[7] - - b OSClearContext -} - -void OSDumpContext(const OSContext* ctx){ - u32 i; - u32* p; - - OSReport("------------------------- Context 0x%08X -------------------------\n", ctx); - - for(i = 0; i < 16; i++){ - OSReport("r%-2d = 0x%08% (14%d) r%-2d = 0x%08% (14%d)\n", i, ctx->gprs[i], ctx->gprs[i], i+16, ctx->gprs[i+16], ctx->gprs[i+16]); -} - OSReport("LR = 0x%08% CR = 0x%08%\n", ctx->lr, ctx->cr); - OSReport("SRR0 = 0x%08% SRR1 = 0x%08%\n", ctx->srr0, ctx->srr1); - - OSReport("\nGQRs----------\n"); - for(i = 0; i < 4; i++){ - OSReport("gqr%d = 0x%08% \t gqr%d = 0x%08%\n", i, ctx->gqrs[i], i+4, ctx->gqrs[i+4]); -} - if (ctx->state & 1){ - OSContext* currentContext; - OSContext fpuContext; - BOOL enabled; - - enabled = OSDisableInterrupts(); - currentContext = OSGetCurrentContext(); - OSClearContext(&fpuContext); - OSSetCurrentContext(&fpuContext); - - OSReport("\n\nFPRS----------\n"); - for(i = 0; i < 32; i += 2) { - OSReport("fr%d \t= %d \t fr%d \t= %d\n", i, (u32)ctx->fprs[i], i + 1, (u32)ctx->fprs[i+1]); - -} - OSClearContext(&fpuContext); - OSSetCurrentContext(currentContext); - OSRestoreInterrupts(enabled); -} - OSReport("\nAddress: Back Chain LR Save\n"); - for (i = 0, p = (u32*)ctx->gprs[1]; p && (u32)p != 0xffffffff && i++ < 16; p = (u32*)*p){ - OSReport("0x%08x: 0x%08x 0x%08x\n", p, p[0], p[1]); -} -} -asm void OSSwitchFPUContext(register u8 err, register OSContext* ctx){ - nofralloc - mfmsr r5 - ori, r5, r5, 0x2000 - mtmsr r5 - isync - - lwz r5, ctx->srr1 - ori r5, r5, 0x2000 - mtspr 0x1b, r5 - lis r3, OS_CURRENT_FPU_CONTEXT@ha - lis r5, OS_CURRENT_FPU_CONTEXT@l - stw ctx, OS_CURRENT_FPU_CONTEXT@l(r3) - cmpw r5, ctx - beq ctxinl - cmpwi r5, 0 - beq ctxnol - bl __OSSaveFPUContext - -ctxnol: - bl __OSLoadFPUContext - -ctxinl: - lwz r3, ctx->cr - mtcrf 0xff, r3 - lwz r3, ctx->lr - mtlr r3 - lwz r3, ctx->srr0 - mtspr 0x1a, r3 - lwz r3, ctx->ctr - mtctr r3 - lwz r3, ctx->xer - mtxer r3 - lhz r3, ctx->mode - rlwinm r3, r3, 0, 0x1f, 0x1d - sth r3, ctx->mode - lwz r5, ctx-gprs[5] - lwz r3, ctx->gprs[3] - lwz r4, ctx->gprs[4] - - rfi -} -void __OSContextInit(void){ - OSSetErrorHandler(OS_ERR_FP_UNAVAIL, OSSwitchFPUContext); - OS_CURRENT_FPU_CONTEXT = NULL; - DBPrintf("FPU-unavailable handler installed\n"); -} - -asm void OSFillFPUContext(register OSContext* ctx);{ - nofralloc - mfmsr r5 - ori r5, r5, 0x2000 - mtmsr r5 - isync - - stfd f0, ctx->fprs[0] - stfd f1, ctx->fprs[1] - stfd f2, ctx->fprs[2] - stfd f3, ctx->fprs[3] - stfd f4, ctx->fprs[4] - stfd f5, ctx->fprs[5] - stfd f6, ctx->fprs[6] - stfd f7, ctx->fprs[7] - stfd f8, ctx->fprs[8] - stfd f9, ctx->fprs[9] - stfd f10, ctx->fprs[10] - stfd f11, ctx->fprs[11] - stfd f12, ctx->fprs[12] - stfd f13, ctx->fprs[13] - stfd f14, ctx->fprs[14] - stfd f15, ctx->fprs[15] - stfd f16, ctx->fprs[16] - stfd f17, ctx->fprs[17] - stfd f18, ctx->fprs[18] - stfd f19, ctx->fprs[19] - stfd f20, ctx->fprs[20] - stfd f21, ctx->fprs[21] - stfd f22, ctx->fprs[22] - stfd f23, ctx->fprs[23] - stfd f24, ctx->fprs[24] - stfd f25, ctx->fprs[25] - stfd f26, ctx->fprs[26] - stfd f27, ctx->fprs[27] - stfd f28, ctx->fprs[28] - stfd f29, ctx->fprs[29] - stfd f30, ctx->fprs[30] - stfd f31, ctx->fprs[31] - - mffs f0 - stfd f0, ctx->fpscr_tmp - lfd f0, ctx->fprs[0] - mfspr r5, 0x398 - rlwinm. r5, r5, 3, 0x1f, 0x1f - beq exit - - psq_st f0, 456(ctx), 0, 0 - psq_st f1, 464(ctx), 0, 0 - psq_st f2, 472(ctx), 0, 0 - psq_st f3, 480(ctx), 0, 0 - psq_st f4, 488(ctx), 0, 0 - psq_st f5, 496(ctx), 0, 0 - psq_st f6, 504(ctx), 0, 0 - psq_st f7, 512(ctx), 0, 0 - psq_st f8, 520(ctx), 0, 0 - psq_st f9, 528(ctx), 0, 0 - psq_st f10, 536(ctx), 0, 0 - psq_st f11, 544(ctx), 0, 0 - psq_st f12, 552(ctx), 0, 0 - psq_st f13, 560(ctx), 0, 0 - psq_st f14, 568(ctx), 0, 0 - psq_st f15, 576(ctx), 0, 0 - psq_st f16, 584(ctx), 0, 0 - psq_st f17, 592(ctx), 0, 0 - psq_st f18, 600(ctx), 0, 0 - psq_st f19, 608(ctx), 0, 0 - psq_st f20, 616(ctx), 0, 0 - psq_st f21, 624(ctx), 0, 0 - psq_st f22, 632(ctx), 0, 0 - psq_st f23, 640(ctx), 0, 0 - psq_st f24, 648(ctx), 0, 0 - psq_st f25, 656(ctx), 0, 0 - psq_st f26, 664(ctx), 0, 0 - psq_st f27, 672(ctx), 0, 0 - psq_st f28, 680(ctx), 0, 0 - psq_st f29, 688(ctx), 0, 0 - psq_st f30, 696(ctx), 0, 0 - psq_st f31, 704(ctx), 0, 0 -} +#include "dolphin/os/OSContext.h" +#include "dolphin/os/OSError.h" +static asm void __OSLoadFPUContext(int unused, register OSContext* ctx){ + nofralloc + lhz r5, ctx->state + clrlwi. r5, r5, 0x1f + beq exit + + lfd f0, ctx->fpscr_temp + mtfs f0 + mfspr r5, 0x398 + rlwinm. r5, r5, 3, 0x1f, 0x1f + beq load_fprs + + psq_l f0, 0x1C8(ctx), 0, 0 + psq_l f1, 0x1D0(ctx), 0, 0 + psq_l f2, 0x1D8(ctx), 0, 0 + psq_l f3, 0x1E0(ctx), 0, 0 + psq_l f4, 0x1E8(ctx), 0, 0 + psq_l f5, 0x1F0(ctx), 0, 0 + psq_l f6, 0x1F8(ctx), 0, 0 + psq_l f7, 0x200(ctx), 0, 0 + psq_l f8, 0x208(ctx), 0, 0 + psq_l f9, 0x210(ctx), 0, 0 + psq_l f10, 0x218(ctx), 0, 0 + psq_l f11, 0x220(ctx), 0, 0 + psq_l f12, 0x228(ctx), 0, 0 + psq_l f13, 0x230(ctx), 0, 0 + psq_l f14, 0x238(ctx), 0, 0 + psq_l f15, 0x240(ctx), 0, 0 + psq_l f16, 0x248(ctx), 0, 0 + psq_l f17, 0x250(ctx), 0, 0 + psq_l f18, 0x258(ctx), 0, 0 + psq_l f19, 0x260(ctx), 0, 0 + psq_l f20, 0x268(ctx), 0, 0 + psq_l f21, 0x270(ctx), 0, 0 + psq_l f22, 0x278(ctx), 0, 0 + psq_l f23, 0x280(ctx), 0, 0 + psq_l f24, 0x288(ctx), 0, 0 + psq_l f25, 0x290(ctx), 0, 0 + psq_l f26, 0x298(ctx), 0, 0 + psq_l f27, 0x2A0(ctx), 0, 0 + psq_l f28, 0x2A8(ctx), 0, 0 + psq_l f29, 0x2B0(ctx), 0, 0 + psq_l f30, 0x2B8(ctx), 0, 0 + psq_l f31, 0x2C0(ctx), 0, 0 + +load_fprs: + lfd f0, ctx->fprs[0] + lfd f1, ctx->fprs[1] + lfd f2, ctx->fprs[2] + lfd f3, ctx->fprs[3] + lfd f4, ctx->fprs[4] + lfd f5, ctx->fprs[5] + lfd f6, ctx->fprs[6] + lfd f7, ctx->fprs[7] + lfd f8, ctx->fprs[8] + lfd f9, ctx->fprs[9] + lfd f10, ctx->fprs[10] + lfd f11, ctx->fprs[11] + lfd f12, ctx->fprs[12] + lfd f13, ctx->fprs[13] + lfd f14, ctx->fprs[14] + lfd f15, ctx->fprs[15] + lfd f16, ctx->fprs[16] + lfd f17, ctx->fprs[17] + lfd f18, ctx->fprs[18] + lfd f19, ctx->fprs[19] + lfd f20, ctx->fprs[20] + lfd f21, ctx->fprs[21] + lfd f22, ctx->fprs[22] + lfd f23, ctx->fprs[23] + lfd f24, ctx->fprs[24] + lfd f25, ctx->fprs[25] + lfd f26, ctx->fprs[26] + lfd f27, ctx->fprs[27] + lfd f28, ctx->fprs[28] + lfd f29, ctx->fprs[29] + lfd f30, ctx->fprs[30] + lfd f31, ctx->fprs[31] + +exit: + blr +} + +static asm void __OSSaveFPUContext( u32 unused, u32 unused1, register OSContext* ctx){ + nofralloc + lhz r3, ctx->state + ori r3, r3, 1 + sth r3, ctx->state + + stfd f0, ctx->fprs[0] + stfd f1, ctx->fprs[1] + stfd f2, ctx->fprs[2] + stfd f3, ctx->fprs[3] + stfd f4, ctx->fprs[4] + stfd f5, ctx->fprs[5] + stfd f6, ctx->fprs[6] + stfd f7, ctx->fprs[7] + stfd f8, ctx->fprs[8] + stfd f9, ctx->fprs[9] + stfd f10, ctx->fprs[10] + stfd f11, ctx->fprs[11] + stfd f12, ctx->fprs[12] + stfd f13, ctx->fprs[13] + stfd f14, ctx->fprs[14] + stfd f15, ctx->fprs[15] + stfd f16, ctx->fprs[16] + stfd f17, ctx->fprs[17] + stfd f18, ctx->fprs[18] + stfd f19, ctx->fprs[19] + stfd f20, ctx->fprs[20] + stfd f21, ctx->fprs[21] + stfd f22, ctx->fprs[22] + stfd f23, ctx->fprs[23] + stfd f24, ctx->fprs[24] + stfd f25, ctx->fprs[25] + stfd f26, ctx->fprs[26] + stfd f27, ctx->fprs[27] + stfd f28, ctx->fprs[28] + stfd f29, ctx->fprs[29] + stfd f30, ctx->fprs[30] + stfd f31, ctx->fprs[31] + + mffs f0 + stfd f0, ctx->fpscr_tmp + lfd f0, ctx->fprs[0] + mfspr r3, 0x398 + rlwinm. r3, r3, 3, 0x1f, 0x1f + beq exit + + psq_st f0, 0x1C8(ctx), 0, 0 + psq_st f1, 0x1D0(ctx), 0, 0 + psq_st f2, 0x1D8(ctx), 0, 0 + psq_st f3, 0x1E0(ctx), 0, 0 + psq_st f4, 0x1E8(ctx), 0, 0 + psq_st f5, 0x1F0(ctx), 0, 0 + psq_st f6, 0x1F8(ctx), 0, 0 + psq_st f7, 0x200(ctx), 0, 0 + psq_st f8, 0x208(ctx), 0, 0 + psq_st f9, 0x210(ctx), 0, 0 + psq_st f10, 0x218(ctx), 0, 0 + psq_st f11, 0x220(ctx), 0, 0 + psq_st f12, 0x228(ctx), 0, 0 + psq_st f13, 0x230(ctx), 0, 0 + psq_st f14, 0x238(ctx), 0, 0 + psq_st f15, 0x240(ctx), 0, 0 + psq_st f16, 0x248(ctx), 0, 0 + psq_st f17, 0x250(ctx), 0, 0 + psq_st f18, 0x258(ctx), 0, 0 + psq_st f19, 0x260(ctx), 0, 0 + psq_st f20, 0x268(ctx), 0, 0 + psq_st f21, 0x270(ctx), 0, 0 + psq_st f22, 0x278(ctx), 0, 0 + psq_st f23, 0x280(ctx), 0, 0 + psq_st f24, 0x288(ctx), 0, 0 + psq_st f25, 0x290(ctx), 0, 0 + psq_st f26, 0x298(ctx), 0, 0 + psq_st f27, 0x2A0(ctx), 0, 0 + psq_st f28, 0x2A8(ctx), 0, 0 + psq_st f29, 0x2B0(ctx), 0, 0 + psq_st f30, 0x2B8(ctx), 0, 0 + psq_st f31, 0x2C0(ctx), 0, 0 + +exit: + blr +} + +asm void OSSetCurrentContext(register OSContext* ctx){ + nofralloc + lis r4, 0x8000 + stw ctx, OS_GET_CURRENT_CONTEXT@l(r4) + clrlwi r5, ctx, 2 + stw r5, OS_CURRENT_CONTEXT_PHYS@l(r4) + lwz r5, OS_CURRENT_FPU_CONTEXT@l(r4) + cmpw r5, ctx + bne not_cur_fpu_ctx + + lwz r6, ctx->srr1 + ori r6, r6, 0x2000 + stw r6, ctx->srr1 + mfmsr r6 + ori r6, r6, 2 + mtmsr r6 + blr + +not_cur_fpu_ctx: + lwz r6, ctx->srr1 + rlwinm r6, r6, 0, 0x13, 0x11 + stw r6, ctx->srr1 + mfmsr r6 + rlwinm r6, r6, 0, 0x13, 0x11 + ori r6, r6, 2 + mtmsr r6 + isync + blr +} + +inline OSContext* OSGetCurrentContext(void) { + return(OS_CURRENT_CONTEXT); +} + +asm BOOL OSSaveContext(register OSContext* ctx){ + nofralloc + stmw r13, ctx->gprs[13] + mfspr r0, 0x391 + stw r3, ctx->gqrs[1] + mfspr r0, 0x392 + stw r3, ctx->gqrs[2] + mfspr r0, 0x393 + stw r3, ctx->gqrs[3] + mfpsr r0, 0x394 + stw r3, ctx->gqrs[4] + mfspr r0, 0x395 + stw r3, ctx->gqrs[5] + mfpsr r0, 0x396 + stw r3, ctx->gqrs[6] + mfspr r0, 0x397 + stw r3, ctx->gqrs[7] + + mfcr r0 + + stw r3, ctx->cr + mflr r0 + stw r3, ctx->lr + stw r3, ctx->srr0 + mfmsr r0 + + stw r3, ctx->srr1 + mfctr r0 + + stw r3, ctx->ctr + mfxer r0 + + stw r3, ctx->xer + + stw r1, ctx->gprs[1] + stw r2, ctx->gprs[2] + li r0, 1 + li r0, 0x0c(r3) + li r3, 0 + + blr +} + + asm void OSLoadContext(register OSContext* ctx){ + nofralloc + lis r4, __RAS_OSDisableInterrupts_begin@ha + lwz r6, ctx->srr0 + addi r5, r4, __RAS_OSDisableInterrupts_begin@l + cmplw r6, r5 + blt- srr0_n_i_ras + lis r4, __RAS_OSDisableInterrupts_end@ha + addi r4 ,r0 __RAS_OSDisableInterrupts_end@l + blg+ srr0_n_i_ras + stw r5, ctx->srr0 + +srr0_n_i_ras: + stw r0, ctx->gprs[0] + stw r1, ctx->gprs[1] + stw r2, ctx->gprs[2] + lhz r4, ctx->state + rlwinm. r4, r5, 0, 0x1e, 0x1e + beq- load_gprs + rlwinm. r4, r5, 0, 0x1f, 0x1d + sth r4, ctx->state + lmw r5, ctx->gprs[5] + b load_spec_gprs + +load_gprs: + lmw r4, ctx->gprs[13] + +load_spec_gprs: + lwz r4, ctx->gqrs[1] + mtspr, 0x391, r4 + lwz r4, ctx->gqrs[2] + mtspr, 0x392, r4 + lwz r4, ctx->gqrs[3] + mtspr, 0x393, r4 + lwz r4, ctx->gqrs[4] + mtspr, 0x394, r4 + lwz r4, ctx->gqrs[5] + mtspr, 0x395, r4 + lwz r4, ctx->gqrs[6] + mtspr, 0x396, r4 + lwz r4, ctx->qgrs[7] + mtspr, 0x397, r4 + + lwz r4, ctx->cr + mtcrf, 0xff, r4 + + lwz r4, ctx->lr + mtlr r4 + + lwz r4, ctx->ctr + mtctr r4 + + lwz r4, ctx->xer + mtxer r4 + mfmsr r4 + rlwinm r4, r4, 0, 0x11, 0xf + rlwinm r4, r4, 0, 0x1f, 0x1d + + mtmsr r4 + lwz r4, ctx->srr0 + mtspr 0x1a, r4 + lwz r4, ctx->srr1 + mtspr 0x1b, r4 + + lwz r4, ctx->gprs[4] + lwz r3, ctx->gprs[3] + + rfi +} + +asm void* OSGetStackPointer(void){ + nofralloc + mr r3, r1 + blr +} + +inline void OSClearContext(OSContext* ctx){ + ctx->mode = 0; + ctx->state = 0; + +if(ctx == OS_CURRENT_FPU_CONTEXT){ + OS_CURRENT_FPU_CONTEXT = NULL; +} +} + +asm void OSInitContext(register OSContext* ctx, register void* srr, register void* sp){ + nofralloc + stw srr, ctx->srr0 + stw sp, ctx->gprs[1] + + li r11, 0 + ori r11, r11, 0x9032 + stw r11, ctx->srr1 + + li r0, 0 + stw r0, ctx->cr + stw r0, ctx->xer + + stw r2, ctx->gprs[2] + stw r13, ctx->gprs[13] + + stw r0, ctx->gprs[3] + stw r0, ctx->gprs[4] + stw r0, ctx->gprs[5] + stw r0, ctx->gprs[6] + stw r0, ctx->gprs[7] + stw r0, ctx->gprs[8] + stw r0, ctx->gprs[9] + stw r0, ctx->gprs[10] + stw r0, ctx->gprs[11] + stw r0, ctx->gprs[12] + stw r0, ctx->gprs[14] + stw r0, ctx->gprs[15] + stw r0, ctx->gprs[16] + stw r0, ctx->gprs[17] + stw r0, ctx->gprs[18] + stw r0, ctx->gprs[19] + stw r0, ctx->gprs[20] + stw r0, ctx->gprs[21] + stw r0, ctx->gprs[22] + stw r0, ctx->gprs[22] + stw r0, ctx->gprs[23] + stw r0, ctx->gprs[24] + stw r0, ctx->gprs[25] + stw r0, ctx->gprs[26] + stw r0, ctx->gprs[27] + stw r0, ctx->gprs[28] + stw r0, ctx->gprs[29] + stw r0, ctx->gprs[30] + stw r0, ctx->gprs[31] + + stw r0, ctx->gqrs[0] + stw r0, ctx->gqrs[1] + stw r0, ctx->gqrs[2] + stw r0, ctx->gqrs[3] + stw r0, ctx->gqrs[4] + stw r0, ctx->gqrs[5] + stw r0, ctx->gqrs[6] + stw r0, ctx->gqrs[7] + + b OSClearContext +} + +void OSDumpContext(const OSContext* ctx){ + u32 i; + u32* p; + + OSReport("------------------------- Context 0x%08X -------------------------\n", ctx); + + for(i = 0; i < 16; i++){ + OSReport("r%-2d = 0x%08% (14%d) r%-2d = 0x%08% (14%d)\n", i, ctx->gprs[i], ctx->gprs[i], i+16, ctx->gprs[i+16], ctx->gprs[i+16]); +} + OSReport("LR = 0x%08% CR = 0x%08%\n", ctx->lr, ctx->cr); + OSReport("SRR0 = 0x%08% SRR1 = 0x%08%\n", ctx->srr0, ctx->srr1); + + OSReport("\nGQRs----------\n"); + for(i = 0; i < 4; i++){ + OSReport("gqr%d = 0x%08% \t gqr%d = 0x%08%\n", i, ctx->gqrs[i], i+4, ctx->gqrs[i+4]); +} + if (ctx->state & 1){ + OSContext* currentContext; + OSContext fpuContext; + BOOL enabled; + + enabled = OSDisableInterrupts(); + currentContext = OSGetCurrentContext(); + OSClearContext(&fpuContext); + OSSetCurrentContext(&fpuContext); + + OSReport("\n\nFPRS----------\n"); + for(i = 0; i < 32; i += 2) { + OSReport("fr%d \t= %d \t fr%d \t= %d\n", i, (u32)ctx->fprs[i], i + 1, (u32)ctx->fprs[i+1]); + +} + OSClearContext(&fpuContext); + OSSetCurrentContext(currentContext); + OSRestoreInterrupts(enabled); +} + OSReport("\nAddress: Back Chain LR Save\n"); + for (i = 0, p = (u32*)ctx->gprs[1]; p && (u32)p != 0xffffffff && i++ < 16; p = (u32*)*p){ + OSReport("0x%08x: 0x%08x 0x%08x\n", p, p[0], p[1]); +} +} +asm void OSSwitchFPUContext(register u8 err, register OSContext* ctx){ + nofralloc + mfmsr r5 + ori, r5, r5, 0x2000 + mtmsr r5 + isync + + lwz r5, ctx->srr1 + ori r5, r5, 0x2000 + mtspr 0x1b, r5 + lis r3, OS_CURRENT_FPU_CONTEXT@ha + lis r5, OS_CURRENT_FPU_CONTEXT@l + stw ctx, OS_CURRENT_FPU_CONTEXT@l(r3) + cmpw r5, ctx + beq ctxinl + cmpwi r5, 0 + beq ctxnol + bl __OSSaveFPUContext + +ctxnol: + bl __OSLoadFPUContext + +ctxinl: + lwz r3, ctx->cr + mtcrf 0xff, r3 + lwz r3, ctx->lr + mtlr r3 + lwz r3, ctx->srr0 + mtspr 0x1a, r3 + lwz r3, ctx->ctr + mtctr r3 + lwz r3, ctx->xer + mtxer r3 + lhz r3, ctx->mode + rlwinm r3, r3, 0, 0x1f, 0x1d + sth r3, ctx->mode + lwz r5, ctx-gprs[5] + lwz r3, ctx->gprs[3] + lwz r4, ctx->gprs[4] + + rfi +} +void __OSContextInit(void){ + OSSetErrorHandler(OS_ERR_FP_UNAVAIL, OSSwitchFPUContext); + OS_CURRENT_FPU_CONTEXT = NULL; + DBPrintf("FPU-unavailable handler installed\n"); +} + +asm void OSFillFPUContext(register OSContext* ctx);{ + nofralloc + mfmsr r5 + ori r5, r5, 0x2000 + mtmsr r5 + isync + + stfd f0, ctx->fprs[0] + stfd f1, ctx->fprs[1] + stfd f2, ctx->fprs[2] + stfd f3, ctx->fprs[3] + stfd f4, ctx->fprs[4] + stfd f5, ctx->fprs[5] + stfd f6, ctx->fprs[6] + stfd f7, ctx->fprs[7] + stfd f8, ctx->fprs[8] + stfd f9, ctx->fprs[9] + stfd f10, ctx->fprs[10] + stfd f11, ctx->fprs[11] + stfd f12, ctx->fprs[12] + stfd f13, ctx->fprs[13] + stfd f14, ctx->fprs[14] + stfd f15, ctx->fprs[15] + stfd f16, ctx->fprs[16] + stfd f17, ctx->fprs[17] + stfd f18, ctx->fprs[18] + stfd f19, ctx->fprs[19] + stfd f20, ctx->fprs[20] + stfd f21, ctx->fprs[21] + stfd f22, ctx->fprs[22] + stfd f23, ctx->fprs[23] + stfd f24, ctx->fprs[24] + stfd f25, ctx->fprs[25] + stfd f26, ctx->fprs[26] + stfd f27, ctx->fprs[27] + stfd f28, ctx->fprs[28] + stfd f29, ctx->fprs[29] + stfd f30, ctx->fprs[30] + stfd f31, ctx->fprs[31] + + mffs f0 + stfd f0, ctx->fpscr_tmp + lfd f0, ctx->fprs[0] + mfspr r5, 0x398 + rlwinm. r5, r5, 3, 0x1f, 0x1f + beq exit + + psq_st f0, 456(ctx), 0, 0 + psq_st f1, 464(ctx), 0, 0 + psq_st f2, 472(ctx), 0, 0 + psq_st f3, 480(ctx), 0, 0 + psq_st f4, 488(ctx), 0, 0 + psq_st f5, 496(ctx), 0, 0 + psq_st f6, 504(ctx), 0, 0 + psq_st f7, 512(ctx), 0, 0 + psq_st f8, 520(ctx), 0, 0 + psq_st f9, 528(ctx), 0, 0 + psq_st f10, 536(ctx), 0, 0 + psq_st f11, 544(ctx), 0, 0 + psq_st f12, 552(ctx), 0, 0 + psq_st f13, 560(ctx), 0, 0 + psq_st f14, 568(ctx), 0, 0 + psq_st f15, 576(ctx), 0, 0 + psq_st f16, 584(ctx), 0, 0 + psq_st f17, 592(ctx), 0, 0 + psq_st f18, 600(ctx), 0, 0 + psq_st f19, 608(ctx), 0, 0 + psq_st f20, 616(ctx), 0, 0 + psq_st f21, 624(ctx), 0, 0 + psq_st f22, 632(ctx), 0, 0 + psq_st f23, 640(ctx), 0, 0 + psq_st f24, 648(ctx), 0, 0 + psq_st f25, 656(ctx), 0, 0 + psq_st f26, 664(ctx), 0, 0 + psq_st f27, 672(ctx), 0, 0 + psq_st f28, 680(ctx), 0, 0 + psq_st f29, 688(ctx), 0, 0 + psq_st f30, 696(ctx), 0, 0 + psq_st f31, 704(ctx), 0, 0 +} diff --git a/src/dolphin/OS/OSDisableInterrupts.c b/src/dolphin/os2/OSDisableInterrupts.c similarity index 85% rename from src/dolphin/OS/OSDisableInterrupts.c rename to src/dolphin/os2/OSDisableInterrupts.c index 4bd7b6c9..dc322d51 100644 --- a/src/dolphin/OS/OSDisableInterrupts.c +++ b/src/dolphin/os2/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 } \ No newline at end of file diff --git a/src/dolphin/OS/OSEnableInterrupts.c b/src/dolphin/os2/OSEnableInterrupts.c similarity index 87% rename from src/dolphin/OS/OSEnableInterrupts.c rename to src/dolphin/os2/OSEnableInterrupts.c index a2dc46a4..e17366f6 100644 --- a/src/dolphin/OS/OSEnableInterrupts.c +++ b/src/dolphin/os2/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 } \ No newline at end of file diff --git a/src/dolphin/OS/OSError.c b/src/dolphin/os2/OSError.c similarity index 94% rename from src/dolphin/OS/OSError.c rename to src/dolphin/os2/OSError.c index d2a152b2..ce0b1a96 100644 --- a/src/dolphin/OS/OSError.c +++ b/src/dolphin/os2/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]; diff --git a/src/dolphin/OS/OSMemory.c b/src/dolphin/os2/OSMemory.c similarity index 91% rename from src/dolphin/OS/OSMemory.c rename to src/dolphin/os2/OSMemory.c index 8c55045c..99708385 100644 --- a/src/dolphin/OS/OSMemory.c +++ b/src/dolphin/os2/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); } \ No newline at end of file diff --git a/src/dolphin/OS/OSRestoreInterrupts.c b/src/dolphin/os2/OSRestoreInterrupts.c similarity index 92% rename from src/dolphin/OS/OSRestoreInterrupts.c rename to src/dolphin/os2/OSRestoreInterrupts.c index 9712f5aa..7739bc2a 100644 --- a/src/dolphin/OS/OSRestoreInterrupts.c +++ b/src/dolphin/os2/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 } \ No newline at end of file diff --git a/src/libultra/ultra.c b/src/libultra/ultra.c index de53f298..d580556a 100644 --- a/src/libultra/ultra.c +++ b/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; From 4412523f93870e392a100c8f302d6466d81b7ebe Mon Sep 17 00:00:00 2001 From: SwareJonge Date: Mon, 20 Feb 2023 09:12:46 +0100 Subject: [PATCH 3/4] rename part 2 --- include/dolphin/{os2 => os}/OSAddress.h | 0 include/dolphin/{os2 => os}/OSAlloc.h | 0 include/dolphin/{os2 => os}/OSArena.h | 0 include/dolphin/{os2 => os}/OSCache.h | 0 include/dolphin/{os2 => os}/OSContext.h | 0 include/dolphin/{os2 => os}/OSError.h | 0 include/dolphin/{os2 => os}/OSMemory.h | 0 include/dolphin/{os2 => os}/OSMutex.h | 0 include/dolphin/{os2 => os}/OSThread.h | 0 include/dolphin/{os2 => os}/OSTime.h | 0 include/dolphin/{os2 => os}/OSUtil.h | 0 src/dolphin/{os2 => os}/OSAlarm.c | 0 src/dolphin/{os2 => os}/OSArena.c | 0 src/dolphin/{os2 => os}/OSAudioSystem.C | 0 src/dolphin/{os2 => os}/OSCache.c | 0 src/dolphin/{os2 => os}/OSContext.c | 0 src/dolphin/{os2 => os}/OSDisableInterrupts.c | 0 src/dolphin/{os2 => os}/OSEnableInterrupts.c | 0 src/dolphin/{os2 => os}/OSError.c | 0 src/dolphin/{os2 => os}/OSMemory.c | 0 src/dolphin/{os2 => os}/OSRestoreInterrupts.c | 0 21 files changed, 0 insertions(+), 0 deletions(-) rename include/dolphin/{os2 => os}/OSAddress.h (100%) rename include/dolphin/{os2 => os}/OSAlloc.h (100%) rename include/dolphin/{os2 => os}/OSArena.h (100%) rename include/dolphin/{os2 => os}/OSCache.h (100%) rename include/dolphin/{os2 => os}/OSContext.h (100%) rename include/dolphin/{os2 => os}/OSError.h (100%) rename include/dolphin/{os2 => os}/OSMemory.h (100%) rename include/dolphin/{os2 => os}/OSMutex.h (100%) rename include/dolphin/{os2 => os}/OSThread.h (100%) rename include/dolphin/{os2 => os}/OSTime.h (100%) rename include/dolphin/{os2 => os}/OSUtil.h (100%) rename src/dolphin/{os2 => os}/OSAlarm.c (100%) rename src/dolphin/{os2 => os}/OSArena.c (100%) rename src/dolphin/{os2 => os}/OSAudioSystem.C (100%) rename src/dolphin/{os2 => os}/OSCache.c (100%) rename src/dolphin/{os2 => os}/OSContext.c (100%) rename src/dolphin/{os2 => os}/OSDisableInterrupts.c (100%) rename src/dolphin/{os2 => os}/OSEnableInterrupts.c (100%) rename src/dolphin/{os2 => os}/OSError.c (100%) rename src/dolphin/{os2 => os}/OSMemory.c (100%) rename src/dolphin/{os2 => os}/OSRestoreInterrupts.c (100%) diff --git a/include/dolphin/os2/OSAddress.h b/include/dolphin/os/OSAddress.h similarity index 100% rename from include/dolphin/os2/OSAddress.h rename to include/dolphin/os/OSAddress.h diff --git a/include/dolphin/os2/OSAlloc.h b/include/dolphin/os/OSAlloc.h similarity index 100% rename from include/dolphin/os2/OSAlloc.h rename to include/dolphin/os/OSAlloc.h diff --git a/include/dolphin/os2/OSArena.h b/include/dolphin/os/OSArena.h similarity index 100% rename from include/dolphin/os2/OSArena.h rename to include/dolphin/os/OSArena.h diff --git a/include/dolphin/os2/OSCache.h b/include/dolphin/os/OSCache.h similarity index 100% rename from include/dolphin/os2/OSCache.h rename to include/dolphin/os/OSCache.h diff --git a/include/dolphin/os2/OSContext.h b/include/dolphin/os/OSContext.h similarity index 100% rename from include/dolphin/os2/OSContext.h rename to include/dolphin/os/OSContext.h diff --git a/include/dolphin/os2/OSError.h b/include/dolphin/os/OSError.h similarity index 100% rename from include/dolphin/os2/OSError.h rename to include/dolphin/os/OSError.h diff --git a/include/dolphin/os2/OSMemory.h b/include/dolphin/os/OSMemory.h similarity index 100% rename from include/dolphin/os2/OSMemory.h rename to include/dolphin/os/OSMemory.h diff --git a/include/dolphin/os2/OSMutex.h b/include/dolphin/os/OSMutex.h similarity index 100% rename from include/dolphin/os2/OSMutex.h rename to include/dolphin/os/OSMutex.h diff --git a/include/dolphin/os2/OSThread.h b/include/dolphin/os/OSThread.h similarity index 100% rename from include/dolphin/os2/OSThread.h rename to include/dolphin/os/OSThread.h diff --git a/include/dolphin/os2/OSTime.h b/include/dolphin/os/OSTime.h similarity index 100% rename from include/dolphin/os2/OSTime.h rename to include/dolphin/os/OSTime.h diff --git a/include/dolphin/os2/OSUtil.h b/include/dolphin/os/OSUtil.h similarity index 100% rename from include/dolphin/os2/OSUtil.h rename to include/dolphin/os/OSUtil.h diff --git a/src/dolphin/os2/OSAlarm.c b/src/dolphin/os/OSAlarm.c similarity index 100% rename from src/dolphin/os2/OSAlarm.c rename to src/dolphin/os/OSAlarm.c diff --git a/src/dolphin/os2/OSArena.c b/src/dolphin/os/OSArena.c similarity index 100% rename from src/dolphin/os2/OSArena.c rename to src/dolphin/os/OSArena.c diff --git a/src/dolphin/os2/OSAudioSystem.C b/src/dolphin/os/OSAudioSystem.C similarity index 100% rename from src/dolphin/os2/OSAudioSystem.C rename to src/dolphin/os/OSAudioSystem.C diff --git a/src/dolphin/os2/OSCache.c b/src/dolphin/os/OSCache.c similarity index 100% rename from src/dolphin/os2/OSCache.c rename to src/dolphin/os/OSCache.c diff --git a/src/dolphin/os2/OSContext.c b/src/dolphin/os/OSContext.c similarity index 100% rename from src/dolphin/os2/OSContext.c rename to src/dolphin/os/OSContext.c diff --git a/src/dolphin/os2/OSDisableInterrupts.c b/src/dolphin/os/OSDisableInterrupts.c similarity index 100% rename from src/dolphin/os2/OSDisableInterrupts.c rename to src/dolphin/os/OSDisableInterrupts.c diff --git a/src/dolphin/os2/OSEnableInterrupts.c b/src/dolphin/os/OSEnableInterrupts.c similarity index 100% rename from src/dolphin/os2/OSEnableInterrupts.c rename to src/dolphin/os/OSEnableInterrupts.c diff --git a/src/dolphin/os2/OSError.c b/src/dolphin/os/OSError.c similarity index 100% rename from src/dolphin/os2/OSError.c rename to src/dolphin/os/OSError.c diff --git a/src/dolphin/os2/OSMemory.c b/src/dolphin/os/OSMemory.c similarity index 100% rename from src/dolphin/os2/OSMemory.c rename to src/dolphin/os/OSMemory.c diff --git a/src/dolphin/os2/OSRestoreInterrupts.c b/src/dolphin/os/OSRestoreInterrupts.c similarity index 100% rename from src/dolphin/os2/OSRestoreInterrupts.c rename to src/dolphin/os/OSRestoreInterrupts.c From 74af2fe41efff3c9dbbc65b85181b5c86d55ea99 Mon Sep 17 00:00:00 2001 From: SwareJonge Date: Mon, 20 Feb 2023 11:23:19 +0100 Subject: [PATCH 4/4] should be good now? --- config/dol_slices.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/config/dol_slices.yml b/config/dol_slices.yml index ef5224dd..261ffcf8 100644 --- a/config/dol_slices.yml +++ b/config/dol_slices.yml @@ -11,18 +11,18 @@ JSystem/JKernel/JKRHeap.cpp: .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]