Chilly Willy said:
Piratero said:
Chilly Willy said:The crt0.s and linkerscript work together to init the data and bss (if needed for the platform) and are particularly important for C++ startup, handling the execution of constructors (which also requires another file I include with the C++ source called crtstuff.c). In general, if a platform I'm looking at already has a crt0.s and linkerscript, I'll work from those as needed. I find that the crt0.s file is usually pretty good already (other than not having .init/.fini support), but the linker scripts are woefully out of date.
So I may or may not use the crt0.s and linker script you have... I figure they will probably need at least a few minor changes. Maybe they won't need any changes at all - I won't know until I check.
What I have planned for the Saturn... well, a few of the "standard" ports I always do for a platform, like Wolf3D and Doom. While the Saturn version of Doom is pretty good, it's still based on the PSX version, which means it's not quite the same as the PC version everyone loves so. So I'll make a nice PC port. It will require the 4M ram cart, but given how damn cheap the ARP carts are, that shouldn't be a problem.
I also plan to get my port of Tremor working. I figure it will be more useful on the Saturn than on the 32X.
I was also looking at a port of OpenJazz (Jazz Jackrabbit 1/2). There's a number of things that are possible on the Saturn due to the extra ram and the CD that aren't on the 32X due to lack of ram.
Piratero said:
/* C++ CTOR / DTOR handling */
#include <stdlib.h>
/* Used by exit procs */
void *__dso_handle = 0;
extern void __call_exitprocs (int code, void *ptr);
typedef void (*func_ptr) (void);
extern func_ptr __CTOR_LIST__[];
extern func_ptr __DTOR_LIST__[];
/* Do all constructors. */
static void __attribute__((used)) __do_global_ctors (void)
{
do
{
unsigned int i, n = (unsigned int) __CTOR_LIST__[0];
for (i = n; i >= 1; i--)
__CTOR_LIST__[i] ();
} while (0);
}
/* Do all destructors. */
static void __attribute__((used)) __do_global_dtors (void)
{
do
{
unsigned int i, n = (unsigned int) __DTOR_LIST__[0];
for (i = 0; i < n; i++)
__DTOR_LIST__[i + 1] ();
} while (0);
}
/* Add function to .init section. */
static void __attribute__((used, section (".init"))) __std_startup (void)
{
atexit (__do_global_dtors); /* First added, last called. */
__do_global_ctors (); /* Do all constructors. */
}
/* Add function to .fini section. */
static void __attribute__((used, section (".fini"))) __std_cleanup (void)
{
__call_exitprocs (0, NULL);
}! do all initializers
mov.l _master_do_init,r0
jsr @r0
nop
...
! purge cache, turn it on, and run main()
mov.l _master_cctl,r0
mov #0x11,r1
mov.b r1,@r0
mov.l _master_go,r0
jsr @r0
nop
! do all finishers
mov.l _master_do_fini,r0
jsr @r0
nop
2:
bra 2b
nop
...
_master_go:
.long _main
_master_do_init:
.long __INIT_SECTION__
_master_do_fini:
.long __FINI_SECTION__OUTPUT_ARCH(sh)
EXTERN (_start)
ENTRY (_start)
__DYNAMIC = 0;
/*
* The memory map look like this:
* +--------------------+ <- 0x02000000
* | .text |
* | |
* | __text_end |
* +--------------------+
* . .
* . .
* . .
* +--------------------+ <- 0x06000000
* | .data | initialized data goes here
* | |
* | __data_end |
* +--------------------+
* | .bss |
* | __bss_start | start of bss, cleared by crt0
* | |
* | __bss__end | start of heap, used by sbrk()
* +--------------------+
* . .
* . .
* . .
* | __stack | top of stack (for Master SH2)
* +--------------------+ <- 0x0603FC00
*/
MEMORY
{
rom (rx) : ORIGIN = 0x02000000, LENGTH = 0x00400000
ram (wx) : ORIGIN = 0x06000000, LENGTH = 0x0003FC00
}
/*
* Allocate the stack to be at the top of memory, since the stack
* grows down
*/
PROVIDE (__stack = 0x0603FC00);
SECTIONS
{
.text 0x02000000 :
AT ( 0x00000000 )
{
__text_start = .;
*(.text)
*(.text.*)
*(.gnu.linkonce.t.*)
. = ALIGN(16);
__INIT_SECTION__ = .;
KEEP (*(.init))
SHORT (0x000B) /* rts */
SHORT (0x0009) /* nop */
. = ALIGN(16);
__FINI_SECTION__ = .;
KEEP (*(.fini))
SHORT (0x000B) /* rts */
SHORT (0x0009) /* nop */
*(.eh_frame_hdr)
KEEP (*(.eh_frame))
*(.gcc_except_table)
KEEP (*(.jcr))
. = ALIGN(16);
__CTOR_LIST__ = .;
___CTOR_LIST__ = .;
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
LONG(0)
__CTOR_END__ = .;
. = ALIGN(16);
__DTOR_LIST__ = .;
___DTOR_LIST__ = .;
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
LONG(0)
__DTOR_END__ = .;
*(.rdata)
*(.rodata)
*(.rodata.*)
*(.gnu.linkonce.r.*)
. = ALIGN(16);
__text_end = .;
} > rom
__text_size = __text_end - __text_start;
.data 0x06000000 :
AT ( LOADADDR (.text) + SIZEOF (.text) )
{
__data_start = .;
*(.data)
*(.data.*)
*(.gnu.linkonce.d.*)
CONSTRUCTORS
*(.lit8)
*(.lit4)
*(.sdata)
*(.sdata.*)
*(.gnu.linkonce.s.*)
. = ALIGN(16);
__data_end = .;
} > ram
__data_size = __data_end - __data_start;
.bss :
{
__bss_start = .;
*(.bss)
*(.bss.*)
*(.gnu.linkonce.b.*)
*(.sbss)
*(.sbss.*)
*(.gnu.linkonce.sb.*)
*(.scommon)
*(COMMON)
end = .;
_end = ALIGN (16);
__end = _end;
__bss_end = .;
} > ram
__bss_size = __bss_end - __bss_start;
}OUTPUT_ARCH(sh)
EXTERN (_start)
ENTRY (_start)
__DYNAMIC = 0;
/*
* The memory map look like this:
* +--------------------+ <- 0x06002000
* | |
* | __stack | top of stack (for Master SH2)
* +--------------------+ <- 0x06004000
* | .text |
* | |
* | __text_end |
* +--------------------+
* | .data | initialized data goes here
* | |
* | __data_end |
* +--------------------+
* | .bss |
* | __bss_start | start of bss, cleared by crt0
* | |
* | __bss__end | start of heap, used by sbrk()
* +--------------------+
* . .
* . .
* . .
* +--------------------+ <- 0x06100000
*/
MEMORY
{
ram (wx) : ORIGIN = 0x06004000, LENGTH = 0x000FC000
}
/*
* The stack is just before the load address on the Saturn
*/
PROVIDE (__stack = 0x06004000);
SECTIONS
{
.text 0x06004000 :
AT ( 0x00000000 )
{
__text_start = .;
*(.text)
*(.text.*)
*(.gnu.linkonce.t.*)
. = ALIGN(16);
__INIT_SECTION__ = .;
KEEP (*(.init))
SHORT (0x000B) /* rts */
SHORT (0x0009) /* nop */
. = ALIGN(16);
__FINI_SECTION__ = .;
KEEP (*(.fini))
SHORT (0x000B) /* rts */
SHORT (0x0009) /* nop */
*(.eh_frame_hdr)
KEEP (*(.eh_frame))
*(.gcc_except_table)
KEEP (*(.jcr))
. = ALIGN(16);
__CTOR_LIST__ = .;
___CTOR_LIST__ = .;
LONG((__CTOR_END__ - __CTOR_LIST__) / 4 - 2)
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
LONG(0)
__CTOR_END__ = .;
. = ALIGN(16);
__DTOR_LIST__ = .;
___DTOR_LIST__ = .;
LONG((__DTOR_END__ - __DTOR_LIST__) / 4 - 2)
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
LONG(0)
__DTOR_END__ = .;
*(.rdata)
*(.rodata)
*(.rodata.*)
*(.gnu.linkonce.r.*)
. = ALIGN(16);
__text_end = .;
} > ram
__text_size = __text_end - __text_start;
.data :
{
__data_start = .;
*(.data)
*(.data.*)
*(.gnu.linkonce.d.*)
CONSTRUCTORS
*(.lit8)
*(.lit4)
*(.sdata)
*(.sdata.*)
*(.gnu.linkonce.s.*)
. = ALIGN(16);
__data_end = .;
} > ram
__data_size = __data_end - __data_start;
.bss :
{
__bss_start = .;
*(.bss)
*(.bss.*)
*(.gnu.linkonce.b.*)
*(.sbss)
*(.sbss.*)
*(.gnu.linkonce.sb.*)
*(.scommon)
*(COMMON)
end = .;
_end = ALIGN (16);
__end = _end;
__bss_end = .;
} > ram
__bss_size = __bss_end - __bss_start;
}Piratero said:
/* Simple Malloc & Free Functions - by [email]malkia@digitald.com[/email] */
#include <string.h>
#define USED 1
typedef struct {
unsigned size;
} UNIT;
typedef struct {
UNIT* free;
UNIT* heap;
} MSYS;
static MSYS msys;
static int msysNumAllocs;
static UNIT* compact( UNIT *p, unsigned nsize )
{
unsigned bsize, psize;
UNIT *best;
best = p;
bsize = 0;
while( psize = p->size, psize )
{
if( psize & USED )
{
if( bsize != 0 )
{
best->size = bsize;
if( bsize >= nsize )
{
return best;
}
}
bsize = 0;
best = p = (UNIT *)( (unsigned)p + (psize & ~USED) );
}
else
{
bsize += psize;
p = (UNIT *)( (unsigned)p + psize );
}
}
if( bsize != 0 )
{
best->size = bsize;
if( bsize >= nsize )
{
return best;
}
}
return 0;
}
void MSYS_Free( void *ptr )
{
if( ptr )
{
UNIT *p;
p = (UNIT *)( (unsigned)ptr - sizeof(UNIT) );
p->size &= ~USED;
}
}
void *MSYS_Malloc( unsigned size )
{
unsigned fsize;
UNIT *p;
msysNumAllocs++;
if( size == 0 ) return 0;
size += 3 + sizeof(UNIT);
size >>= 2;
size <<= 2;
if( msys.free == 0 || size > msys.free->size )
{
msys.free = compact( msys.heap, size );
if( msys.free == 0 ) return 0;
}
p = msys.free;
fsize = msys.free->size;
if( fsize >= size + sizeof(UNIT) )
{
msys.free = (UNIT *)( (unsigned)p + size );
msys.free->size = fsize - size;
}
else
{
msys.free = 0;
size = fsize;
}
p->size = size | USED;
return (void *)( (unsigned)p + sizeof(UNIT) );
}
void *MSYS_Calloc( unsigned cnt, unsigned size )
{
void *ptr = MSYS_Malloc( cnt*size );
if (ptr)
memset(ptr, 0, cnt*size);
return ptr;
}
void *MSYS_Realloc( void *mem, unsigned new_size )
{
void *ptr;
// special cases
if (!mem)
return MSYS_Malloc( new_size );
if (!new_size)
{
MSYS_Free( mem );
return MSYS_Malloc( new_size );
}
// just alloc a new block and copy
ptr = MSYS_Malloc( new_size );
if (ptr)
{
memcpy(ptr, mem, new_size);
MSYS_Free( mem );
}
return ptr;
}
void MSYS_Init( void *heap, unsigned len, MSYS *ptr )
{
msysNumAllocs = 0;
len += 3;
len >>= 2;
len <<= 2;
msys.free = msys.heap = (UNIT *) heap;
msys.free->size = msys.heap->size = len - sizeof(UNIT);
*(unsigned *)((char *)heap + len - 4) = 0;
if (ptr)
{
ptr->free = msys.free;
ptr->heap = msys.heap;
}
}
void MSYS_Compact( void )
{
msys.free = compact( msys.heap, 0x7FFFFFFF );
}
void MSYS_Set( MSYS *ptr )
{
msys.free = ptr->free;
msys.heap = ptr->heap;
}#ifndef _MSYS_H_
#define _MSYS_H_
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
typedef struct {
unsigned size;
} UNIT;
typedef struct {
UNIT* free;
UNIT* heap;
} MSYS;
extern void MSYS_Free( void *ptr );
extern void *MSYS_Malloc( unsigned size );
extern void *MSYS_Calloc( unsigned cnt, unsigned size );
extern void *MSYS_Realloc( void *mem, unsigned size );
extern void MSYS_Init( void *heap, unsigned len, MSYS *ptr );
extern void MSYS_Compact( void );
extern void MSYS_Set( MSYS *ptr );
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endifChilly Willy said:Anything I do is MIT unless otherwise stated, or based off an existing base with its own license (obviously, I can't change GPL code to something else).
I've mentioned my licensing in a few places before, but I really should get around to sticking these things in the files. MIT or the new BSD license are fine with me - I want anything I do to be as useful to as many people as possible.
Joe Fenton <jlfenton65@gmail.com> is fine for the author/contact.
Chilly Willy said:
Chilly Willy said:Make a third allocator from msys called vsys for the VDP1, then just alloc blocks as needed, and reinit the zone to clear everything at once. Maybe FOUR allocators from msys: one for the Master SH2, one for the Slave SH2, one for VDP1, and one for VDP2.
I've thought of altering msys to take a zone for an input argument. Then you could have any number of zones. For VDP1, allocate a block from the main vram zone, then create a new zone using that block for tables and whatnot. Then you can clear everything associated with one zone without affecting the others. Zones inside zones...
Piratero said:
! void SVC_Lock(int16_t id)
! Entry: r4 = id
.global _SVC_Lock
_SVC_Lock:
exts.w r4,r4
mov.l ss_svc_state,r1
0:
mov.w @r1,r0
cmp/eq #1,r0 /* loop until unlocked */
bf 0b
mov.w r4,@r1
mov.w @r1,r0
cmp/eq r4,r0
bf 0b /* race condition - we lost */
rts
nop
! void SVC_Unlock(void)
.global _SVC_Unlock
_SVC_Unlock:
mov #1,r0
mov.l ss_svc_state,r1
rts
mov.w r0,@r1Piratero said:
Piratero said:
Chilly Willy said:
ExCyber said:
Chilly Willy said:One thing I found from my own C++ example - do not include iostream! The linker doesn't seem able to tell what code is used and what isn't due to the binary bits at the start of console binaries (at least not on the MD and 32X). That means that whatever you include is left in its entirety in the binary at the end... which means my 8K TicTacToe ballooned to several HUNDRED K. The iostream is HUGE, mainly because it deals with text in and out.
Oh, that's nice! I saw that in RockBox, but the license was different. I didn't see this one.
With old, slow consoles (and computers), it's often best to ignore as much of that as possible. Always locking/unlocking can kill your performance, and having the extra overhead of actual threads can cut speeds by a third or worse. That said, sometimes you NEED locking between two CPU (32X or Saturn). For example, my sound mixer for the 32X: the Master SH2 sets/changes the entries in the voice table, but the Slave goes through the table to do the mixing. Clearly, I need to lock the list from one side or the other for changes/mixing. The interface in the 32X is not designed handle TAS atomic bus cycles, so I wound up using one of the communications registers like this:
Code:...
That worked well - the communications registers are fast and uncached, and can be read and written by both CPUs at the same time. Since they CAN both write at the same time, it's not guaranteed which CPU will actually have it's data stored; hence the race condition check.
The Saturn doesn't have communications registers. I'm also not sure if any of the blocks of ram are capable of TAS - I haven't seen anything about that in any of the manuals yet. Code like above can be done on uncached ram, but would be slower if the ram is wired for burst read access.
If you need extra info on how to go through a list of data, a linked list or tree is better. If you don't have that, just allocating blocks is probably better. Sounds like a list/tree is what you want here, from the example.
Back when I was using it on the 32X for Tremor, I hunted around until I found a post from malkia where he told someone the code can be used any way they wish.
By the way, I'm sure you're familiar with this forum?
https://mollyrocket.com/forums/viewforum.php?f=16
That's one of the best sites for PD code for things. stb_image.c is one of the most widely used pieces of PD code out.
Sounds good so far. I'll go over it more thoroughly when you have more to go over.
If the scheme gets too wasteful, people can always just allocate a large block to cover all their data instead of handling it individually. Something to keep in mind - in 3D many folks put a BUNCH of different textures in the same texture block. That's because many GPUs require textures to be powers of two in both directions, meaning lots of waste for single textures in many cases... unless you pack more than one texture in the same block.
Chilly Willy said:
antime said:
Vcc
Midi RxD
Midi TxD
Master TxD
Master RxD
Master SCK
GND
Slave TxD
Slave RxD
Slave SCK
GNDPiratero said:
