Discovered or perhaps rediscovered around 2006 by AtariOwl and Gorf here are the rules for working around the bug that stops the GPU from successfully running code out of main memory:
RISC in Main RAM rules:
Here they are in a nutshell.
Page is one block of 256 bytes.
All JUMP Instructions must sit on an address ending in 0,4,8 or C hex
All JUMP Instructions must jump to an address to an external page on 0,4,8 or C Hex
All JUMP Instructions must jump to an address with in a page on 2,6,A or E Hex
The JR instruction can sit any where
The JR instruction follows the same destination rules as jump.
all JUMP or JR instructions must be followed by two NOP's but certain instructions can be used in place of the first NOP.
Stay away from tight loops out in main ram.
Since Owl already revealed it, I'll post once again main to local and local to main.
JUMP instructions only.....must sit on an address ending in 0 or 8 hex...to or from local to main and main to local.
Though they may
not be needed to be done by hand anymore because SMAC(SubQMods Macro Assembler) is suppose to have some macro functionality to handle these rules automatically if you want to use them,(see instructions included with SMAC)
Further reading:http://atariowlproject.blogspot.com/sea ... 0in%20Main
This workaround does not appear to have been known by HVS but McGroarty talks about something like this in a slashdot response to Carmack:
Subject: Ah, the Jaguar... (Score:1)
Date: Sunday March 05, @08:07AM EST
Forum: Slashdot com
>The little RISC engines were decent processors. [...] the only
>thing truly wrong with them was that they had scratchpad memory
>instead of caches, and couldn't execute code from main memory.
>I had to chunk the DOOM renderer into nine sequentially loaded
>overlays to get it working (with hindsight, I would have done it
>differently in about three...)
Actually, you could execute code out of main memory. You merely had to be
careful about crossing page boundaries because the instruction pointer
wouldn't update properly. I'd say the biggest problem with the processors was
Atari & Brainstorm's documentation. =)
We manually paged pieces in for NBA Jam, White Men Can't Jump and Ruiner
Pinball. Vid Grid sat entirely in one chunk on either RISC with the 68000 just
facilitating major modes. (and you thought 64k games were gone!)
For Dactyl Joust, we were using an automatic memory paging system which was
started with Ruiner. This worked by augmenting function calls to load in each
function in 256-byte chunks, as many as needed, and doing address fixups.
Rarely-called support routines remained in main store, specially tagged to
avoid being loaded in. (See above re: running from main RAM and crossing page
boundaries. The addresses had to be guaranteed by creating a million sections
in the link file. Can you say link file nightmare?) In the end though, C and
eventually C++ use became pretty invisible (read easy and efficient) even on
the GPU RISC processor.
Going back and looking at Jaguar code again when I did Tempest/X3 for
Playstation was a total trip. Even just a couple years later, I'd forgotten
how fun/weird/ugly that beastie was. I honestly miss it though. I really do.
For all its quirks (especially because of its quirks!) it was a great little