|Re: Java virtual machine as target language for C/C++ email@example.com (1996-05-08)|
|Re: Optimization of Uncommon Code (Was Java ByteCode ...) firstname.lastname@example.org (Walter Spector) (1996-07-01)|
|Re: Optimization of Uncommon Code email@example.com (Dwight VandenBerghe) (1996-07-02)|
|Re: Optimization of Uncommon Code firstname.lastname@example.org (Jerry Leichter) (1996-07-03)|
|Re: Recursion and Code Generation on the Cybers and other stackless ma email@example.com (1996-07-04)|
|From:||firstname.lastname@example.org (David Moisan)|
|Date:||4 Jul 1996 15:31:36 -0400|
|References:||96-05-061 96-07-021 96-07-031 96-07-034|
Jerry Leichter <email@example.com> wrote:
>Dwight VandenBerghe commented on the wide use of the 360 (and of
>more-or-less 360 clones) back in the days when FORTRAN (and COBOL) were
>The procedure call on the 6600 saved the return address *at a fixed location
>in memory*. More precisely, the address you specified was of the word
>*before* the first instruction of the procedure. The hardware saved the
The Cyber 170 machines--which are probably still running somewhere, used
this method, and this machine I was using in the mid '80's, so it's not as
historical as one would think.
>return address there, then jumped to the next instruction. (Even more
>precisely, what it saved in that word was a jump instruction back to the
>caller! A procedure exited by jumping to its entry point.)
And if you screwed up and tried to enter the routine without an RJ
(return-jump), you found out real fast as the first word being jumped to for
the return would be all zeros and thus cause an illegal-instruction trap.
>There was, of course, no hardware stack. Creating and using one for data
>would be very easy. Pushing the return address - well, the return
>*instruction* - on the stack would cost you three instructions. You'd
>presumably return by simply jumping into the stack. Not too bad - but not
The CDC Pascal compiler did this, as did the Tiny Pascal compiler I wrote
for my senior project.
>done by any of the standard compilers, and certainly not by either of CDC's
>FORTRAN compilers. Recursion was unknown in the FORTRAN world - and the
>COBOL world. Add those together and you have almost all the American
>programming community through the '60's.
Looking at FORTRAN and the Cyber, it's not hard for me to imagine how the
architecture formed. When I was FORTRAN coding as an undergrad (albeit a
different generation than most of you here) and learning COMPASS (the Cyber
assembly language) on my own, I'd swear I could imagine the assembly
instructions ("...SA1 X1*x2....SB0 37...RJ =CPM...") forming as I wrote my
Keeping this on topic (with apologies to the moderator), other than the
recursion limitations, how did you find the Cyber machines for code
generation? Myself, I miss the Cybers. Quirky, but the code was orthogonal
and very easy to write; only the PDP-11 was close IMHO. (I'm trying to
imagine our moderator coding on a PDP-8, being an owner of one myself. I
Too bad most of my old printouts are in boxes, or I'd look over my
Pascal compiler and explain more about how I did it, or attempted to.
Sorry for rambling, but I loved the CDC machines...
| David Moisan, N1KGH Email: firstname.lastname@example.org |
| WWW: http://www.shore.net/~dmoisan email@example.com |
| Invisible Disabilities Page: |
| http://www.shore.net/~dmoisan/invisible_disability.html |
Return to the
Search the comp.compilers archives again.