kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rename jmp_buf due to a name collision in STD

Browse source
This commit is contained in:
dbalatoni13 2025-04-02 04:52:55 +02:00
parent 84801ecdc7
commit 5eb32764a5
4 changed files with 79 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

8
include/game/jmp.h
View file

@ -3,7 +3,7 @@
#include "dolphin.h" #include "dolphin.h"
typedef struct jump_buf { typedef struct JMPBUF {
u32 lr; u32 lr;
u32 cr; u32 cr;
u32 sp; u32 sp;
@ -11,9 +11,9 @@ typedef struct jump_buf {
u32 pad; u32 pad;
u32 regs[19]; u32 regs[19];
double flt_regs[19]; double flt_regs[19];
} jmp_buf; } JMPBUF;
s32 gcsetjmp(jmp_buf *jump); s32 gcsetjmp(JMPBUF *jump);
s32 gclongjmp(jmp_buf *jump, s32 status); s32 gclongjmp(JMPBUF *jump, s32 status);
#endif #endif

7
include/game/process.h
View file

@ -1,8 +1,9 @@
#ifndef _GAME_PROCESS_H #ifndef _GAME_PROCESS_H
#define _GAME_PROCESS_H #define _GAME_PROCESS_H
#include "game/jmp.h"
#include "dolphin/types.h" #include "dolphin/types.h"
#include "game/jmp.h"
#define PROCESS_STAT_PAUSE 0x1 #define PROCESS_STAT_PAUSE 0x1
#define PROCESS_STAT_UPAUSE 0x2 #define PROCESS_STAT_UPAUSE 0x2
@ -22,7 +23,7 @@ typedef struct process {
u16 prio; u16 prio;
s32 sleep_time; s32 sleep_time;
u32 base_sp; u32 base_sp;
jmp_buf jump; JMPBUF jump;
void (*dtor)(void); void (*dtor)(void);
void *user_data; void *user_data;
} Process; } Process;
@ -50,4 +51,4 @@ void HuPrcResetStat(Process *process, u16 value);
void HuPrcAllPause(s32 flag); void HuPrcAllPause(s32 flag);
void HuPrcAllUPause(s32 flag); void HuPrcAllUPause(s32 flag);
#endif #endif

5
src/game/jmp.c
View file

@ -1,6 +1,7 @@
#include "game/jmp.h" #include "game/jmp.h"
s32 gcsetjmp(register jmp_buf *jump) { s32 gcsetjmp(register JMPBUF *jump)
{
// clang-format off // clang-format off
asm { asm {
mflr r5 mflr r5
@ -36,7 +37,7 @@ s32 gcsetjmp(register jmp_buf *jump) {
} }
// clang-format off // clang-format off
asm s32 gclongjmp(register jmp_buf *jump, register s32 status) { asm s32 gclongjmp(register JMPBUF *jump, register s32 status) {
nofralloc nofralloc
lwz r5, jump->lr lwz r5, jump->lr
lwz r6, jump->cr lwz r6, jump->cr

126
src/game/process.c
View file

@ -1,6 +1,7 @@
#include "game/process.h" #include "game/process.h"
#include "game/memory.h"
#include "dolphin/os.h" #include "dolphin/os.h"
#include "game/memory.h"
#define FAKE_RETADDR 0xA5A5A5A5 #define FAKE_RETADDR 0xA5A5A5A5
@ -9,7 +10,7 @@
#define EXEC_CHILDWATCH 2 #define EXEC_CHILDWATCH 2
#define EXEC_KILLED 3 #define EXEC_KILLED 3
static jmp_buf processjmpbuf; static JMPBUF processjmpbuf;
static Process *processtop; static Process *processtop;
static Process *processcur; static Process *processcur;
static u16 processcnt; static u16 processcnt;
@ -21,8 +22,9 @@ void HuPrcInit(void)
processtop = NULL; processtop = NULL;
} }
static void LinkProcess(Process** root, Process* process) { static void LinkProcess(Process **root, Process *process)
Process* src_process = *root; {
Process *src_process = *root;
if (src_process && (src_process->prio >= process->prio)) { if (src_process && (src_process->prio >= process->prio)) {
while (src_process->next && src_process->next->prio >= process->prio) { while (src_process->next && src_process->next->prio >= process->prio) {
@ -35,7 +37,8 @@ static void LinkProcess(Process** root, Process* process) {
if (process->next) { if (process->next) {
process->next->prev = process; process->next->prev = process;
} }
} else { }
else {
process->next = (*root); process->next = (*root);
process->prev = NULL; process->prev = NULL;
*root = process; *root = process;
@ -44,13 +47,15 @@ static void LinkProcess(Process** root, Process* process) {
} }
} }
} }
static void UnlinkProcess(Process **root, Process *process) { static void UnlinkProcess(Process **root, Process *process)
{
if (process->next) { if (process->next) {
process->next->prev = process->prev; process->next->prev = process->prev;
} }
if (process->prev) { if (process->prev) {
process->prev->next = process->next; process->prev->next = process->next;
} else { }
else {
*root = process->next; *root = process->next;
} }
} }
@ -60,13 +65,11 @@ Process *HuPrcCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_siz
Process *process; Process *process;
s32 alloc_size; s32 alloc_size;
void *heap; void *heap;
if(stack_size == 0) { if (stack_size == 0) {
stack_size = 2048; stack_size = 2048;
} }
alloc_size = HuMemMemoryAllocSizeGet(sizeof(Process)) alloc_size = HuMemMemoryAllocSizeGet(sizeof(Process)) + HuMemMemoryAllocSizeGet(stack_size) + HuMemMemoryAllocSizeGet(extra_size);
+HuMemMemoryAllocSizeGet(stack_size) if (!(heap = HuMemDirectMalloc(HEAP_SYSTEM, alloc_size))) {
+HuMemMemoryAllocSizeGet(extra_size);
if(!(heap = HuMemDirectMalloc(HEAP_SYSTEM, alloc_size))) {
OSReport("process> malloc error size %d\n", alloc_size); OSReport("process> malloc error size %d\n", alloc_size);
return NULL; return NULL;
} }
@ -77,7 +80,7 @@ Process *HuPrcCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_siz
process->stat = 0; process->stat = 0;
process->prio = prio; process->prio = prio;
process->sleep_time = 0; process->sleep_time = 0;
process->base_sp = ((u32)HuMemMemoryAlloc(heap, stack_size, FAKE_RETADDR))+stack_size-8; process->base_sp = ((u32)HuMemMemoryAlloc(heap, stack_size, FAKE_RETADDR)) + stack_size - 8;
gcsetjmp(&process->jump); gcsetjmp(&process->jump);
process->jump.lr = (u32)func; process->jump.lr = (u32)func;
process->jump.sp = process->base_sp; process->jump.sp = process->base_sp;
@ -93,7 +96,7 @@ Process *HuPrcCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extra_siz
void HuPrcChildLink(Process *parent, Process *child) void HuPrcChildLink(Process *parent, Process *child)
{ {
HuPrcChildUnlink(child); HuPrcChildUnlink(child);
if(parent->child) { if (parent->child) {
parent->child->first_child = child; parent->child->first_child = child;
} }
child->next_child = parent->child; child->next_child = parent->child;
@ -104,13 +107,14 @@ void HuPrcChildLink(Process *parent, Process *child)
void HuPrcChildUnlink(Process *process) void HuPrcChildUnlink(Process *process)
{ {
if(process->parent) { if (process->parent) {
if(process->next_child) { if (process->next_child) {
process->next_child->first_child = process->first_child; process->next_child->first_child = process->first_child;
} }
if(process->first_child) { if (process->first_child) {
process->first_child->next_child = process->next_child; process->first_child->next_child = process->next_child;
} else { }
else {
process->parent->child = process->next_child; process->parent->child = process->next_child;
} }
process->parent = NULL; process->parent = NULL;
@ -127,9 +131,9 @@ Process *HuPrcChildCreate(void (*func)(void), u16 prio, u32 stack_size, s32 extr
void HuPrcChildWatch() void HuPrcChildWatch()
{ {
Process *curr = HuPrcCurrentGet(); Process *curr = HuPrcCurrentGet();
if(curr->child) { if (curr->child) {
curr->exec = EXEC_CHILDWATCH; curr->exec = EXEC_CHILDWATCH;
if(!gcsetjmp(&curr->jump)) { if (!gcsetjmp(&curr->jump)) {
gclongjmp(&processjmpbuf, 1); gclongjmp(&processjmpbuf, 1);
} }
} }
@ -142,18 +146,19 @@ Process *HuPrcCurrentGet()
static s32 SetKillStatusProcess(Process *process) static s32 SetKillStatusProcess(Process *process)
{ {
if(process->exec != EXEC_KILLED) { if (process->exec != EXEC_KILLED) {
HuPrcWakeup(process); HuPrcWakeup(process);
process->exec = EXEC_KILLED; process->exec = EXEC_KILLED;
return 0; return 0;
} else { }
else {
return -1; return -1;
} }
} }
s32 HuPrcKill(Process *process) s32 HuPrcKill(Process *process)
{ {
if(process == NULL) { if (process == NULL) {
process = HuPrcCurrentGet(); process = HuPrcCurrentGet();
} }
HuPrcChildKill(process); HuPrcChildKill(process);
@ -164,8 +169,8 @@ s32 HuPrcKill(Process *process)
void HuPrcChildKill(Process *process) void HuPrcChildKill(Process *process)
{ {
Process *child = process->child; Process *child = process->child;
while(child) { while (child) {
if(child->child) { if (child->child) {
HuPrcChildKill(child); HuPrcChildKill(child);
} }
SetKillStatusProcess(child); SetKillStatusProcess(child);
@ -176,7 +181,7 @@ void HuPrcChildKill(Process *process)
static void gcTerminateProcess(Process *process) static void gcTerminateProcess(Process *process)
{ {
if(process->dtor) { if (process->dtor) {
process->dtor(); process->dtor();
} }
UnlinkProcess(&processtop, process); UnlinkProcess(&processtop, process);
@ -195,11 +200,11 @@ void HuPrcEnd()
void HuPrcSleep(s32 time) void HuPrcSleep(s32 time)
{ {
Process *process = HuPrcCurrentGet(); Process *process = HuPrcCurrentGet();
if(time != 0 && process->exec != EXEC_KILLED) { if (time != 0 && process->exec != EXEC_KILLED) {
process->exec = EXEC_SLEEP; process->exec = EXEC_SLEEP;
process->sleep_time = time; process->sleep_time = time;
} }
if(!gcsetjmp(&process->jump)) { if (!gcsetjmp(&process->jump)) {
gclongjmp(&processjmpbuf, 1); gclongjmp(&processjmpbuf, 1);
} }
} }
@ -231,49 +236,52 @@ void HuPrcCall(s32 tick)
s32 ret; s32 ret;
processcur = processtop; processcur = processtop;
ret = gcsetjmp(&processjmpbuf); ret = gcsetjmp(&processjmpbuf);
while(1) { while (1) {
switch(ret) { switch (ret) {
case 2: case 2:
HuMemDirectFree(processcur->heap); HuMemDirectFree(processcur->heap);
case 1: case 1:
if(((u8 *)(processcur->heap))[4] != 165) { if (((u8 *)(processcur->heap))[4] != 165) {
printf("stack overlap error.(process pointer %x)\n", processcur); printf("stack overlap error.(process pointer %x)\n", processcur);
while(1); while (1)
} else { ;
}
else {
processcur = processcur->next; processcur = processcur->next;
} }
break; break;
} }
process = processcur; process = processcur;
if(!process) { if (!process) {
return; return;
} }
procfunc = process->jump.lr; procfunc = process->jump.lr;
if((process->stat & (PROCESS_STAT_PAUSE|PROCESS_STAT_UPAUSE)) && process->exec != EXEC_KILLED) { if ((process->stat & (PROCESS_STAT_PAUSE | PROCESS_STAT_UPAUSE)) && process->exec != EXEC_KILLED) {
ret = 1; ret = 1;
continue; continue;
} }
switch(process->exec) { switch (process->exec) {
case EXEC_SLEEP: case EXEC_SLEEP:
if(process->sleep_time > 0) { if (process->sleep_time > 0) {
process->sleep_time -= tick; process->sleep_time -= tick;
if(process->sleep_time <= 0) { if (process->sleep_time <= 0) {
process->sleep_time = 0; process->sleep_time = 0;
process->exec = EXEC_NORMAL; process->exec = EXEC_NORMAL;
} }
} }
ret = 1; ret = 1;
break; break;
case EXEC_CHILDWATCH: case EXEC_CHILDWATCH:
if(process->child) { if (process->child) {
ret = 1; ret = 1;
} else { }
else {
process->exec = EXEC_NORMAL; process->exec = EXEC_NORMAL;
ret = 0; ret = 0;
} }
break; break;
case EXEC_KILLED: case EXEC_KILLED:
process->jump.lr = (u32)HuPrcEnd; process->jump.lr = (u32)HuPrcEnd;
case EXEC_NORMAL: case EXEC_NORMAL:
@ -307,20 +315,21 @@ void HuPrcResetStat(Process *process, u16 value)
void HuPrcAllPause(s32 flag) void HuPrcAllPause(s32 flag)
{ {
Process *process = processtop; Process *process = processtop;
if(flag) { if (flag) {
while(process != NULL) { while (process != NULL) {
if(!(process->stat & PROCESS_STAT_PAUSE_EN)) { if (!(process->stat & PROCESS_STAT_PAUSE_EN)) {
HuPrcSetStat(process, PROCESS_STAT_PAUSE); HuPrcSetStat(process, PROCESS_STAT_PAUSE);
} }
process = process->next; process = process->next;
} }
} else { }
while(process != NULL) { else {
if(process->stat & PROCESS_STAT_PAUSE) { while (process != NULL) {
if (process->stat & PROCESS_STAT_PAUSE) {
HuPrcResetStat(process, PROCESS_STAT_PAUSE); HuPrcResetStat(process, PROCESS_STAT_PAUSE);
} }
process = process->next; process = process->next;
} }
} }
@ -329,20 +338,21 @@ void HuPrcAllPause(s32 flag)
void HuPrcAllUPause(s32 flag) void HuPrcAllUPause(s32 flag)
{ {
Process *process = processtop; Process *process = processtop;
if(flag) { if (flag) {
while(process != NULL) { while (process != NULL) {
if(!(process->stat & PROCESS_STAT_UPAUSE_EN)) { if (!(process->stat & PROCESS_STAT_UPAUSE_EN)) {
HuPrcSetStat(process, PROCESS_STAT_UPAUSE); HuPrcSetStat(process, PROCESS_STAT_UPAUSE);
} }
process = process->next; process = process->next;
} }
} else { }
while(process != NULL) { else {
if(process->stat & PROCESS_STAT_UPAUSE) { while (process != NULL) {
if (process->stat & PROCESS_STAT_UPAUSE) {
HuPrcResetStat(process, PROCESS_STAT_UPAUSE); HuPrcResetStat(process, PROCESS_STAT_UPAUSE);
} }
process = process->next; process = process->next;
} }
} }