From: muta...@gmail.com   
      
   On Sunday, July 18, 2021 at 12:39:29 AM UTC+10, Scott Lurndal wrote:   
      
   > >That processor with no visible registers sounds like a   
   > >pie-in-the-sky design to me. You may as well design   
   > >the x64 in 1970. You can do anything on paper.   
      
   > There was at least one such system in existence in by 1961.   
   >   
   > The Burroughs B5000/B5500.   
   >   
   > By 1972, the HP-3000 was released which also   
   > had no programmer visible registers.   
   >   
   > Both were stack-based architectures programmed in high   
   > level languages only (The B5500 OS was written in a   
   > flavor of Algol, while the HP-3000 OS was written   
   > in SPL/3000).   
      
   Ok, I did some research on some Burroughs some months   
   ago seeing what C would look like on it, and I couldn't see   
   how to replace the Burroughs-provided C compiler. The   
   provided C compiler made a claim that it was implemented   
   based on the low-level knowledge of the system, but I wasn't   
   able to find out that low-level knowledge to do the same   
   thing they had done.   
      
   At the end of the day, the compiler needs to produce something.   
   If it isn't machine code that manipulates registers, then it needs   
   to be some sort of interpreted P-code like I think some Pascal   
   compilers produce. And Java produces too. I guess you can   
   then tell the system that you want to run that, and it can do its   
   own translation of P-code to machine code to keep things   
   semi-sensible. And you could prevent anyone from directly   
   presenting their own machine code, or viewing generated   
   machine code.   
      
   But surely that translation infrastructure would be done outside   
   the CPU itself? The CPU would be using normal registers.   
   I guess you could load some code into the cache RAM in the   
   CPU, if they had that available. But the generated machine code   
   would need to be written back to normal RAM because there's too   
   much of it.   
      
   You could be non-sensible instead and just make the CPU only   
   interpret P-code.   
      
   But in either of these scenarios, what is needed at the C code   
   level is to generate P-code, and be as crappy as Pascal.   
      
   And I can't think of how the Burroughs-provided C compiler   
   could generate special P-code that took advantage of   
   insider knowledge. Unless it is the P-code itself that is   
   undocumented, forcing you to use their compilers for   
   everything, unless you want to reverse-engineer some   
   executables.   
      
   So I wonder what they did. And they presumably had some   
   level of commercial success with their abnormal infrastructure.   
      
   BFN. Paul.   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)