Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.1 6/24/83 (MC840302); site kuling.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!gamma!epsilon!zeta!sabre!petrus!bellcore!decvax!genrad!panda!talcott!harvard!seismo!mcvax!enea!kuling!grzm
From: grzm@kuling.UUCP (Gunnar Blomberg/ADB)
Newsgroups: net.arch
Subject: What I miss in micro-processors (fairly long)
Message-ID: <796@kuling.UUCP>
Date: Sat, 31-Aug-85 04:40:51 EDT
Article-I.D.: kuling.796
Posted: Sat Aug 31 04:40:51 1985
Date-Received: Thu, 5-Sep-85 06:52:44 EDT
Reply-To: grzm@kuling.UUCP (Gunnar Blomberg/ADB)
Organization: Dept. of Comp.Sc., Uppsala University
Lines: 49
Keywords: Stack overflow detection, Fast subroutine call


        I've been working in assembly language on micro-processors quite
a lot recently and there are a couple of features I've been missing
rather badly (please forgive me if these have been mentioned before,
I've very recently begun reading news).  I would be very glad for views
from other users on what kind of thing they would like to see included
as well as some response from the people who design these things (Is it
really true that the chips are designed solely by people who know
hardware and not software?  (the stuff from Intel would certainly
suggest that that is true...) :-))

1. Stack overflow detection.
 
  This is the one that really bugs me.  I don't know of any
micro-processor that does this.  Why is that?  In my mind this is
something that is badly needed, and coding the check inline would be too
much of a performance penalty.  This is also fundamentally different
from things like array bounds checking which, in principle, need only
be done while debugging the program and should never appear in a
"correct" program.  This is not true of stack overflow which can happen
in a perfectly good program.
  I am aware that many systems let their mmu handle the problem, but
that doesn't seem like a very good solution to me (it doesn't check for
stack overflow, only memory references "just above" the stack limit,
right?) and it doesn't help at all if the system doesn't have an mmu
(yes, all systems *should* have one, but...).

2. A quick subroutine call.

  What I would reaaly like to see here is something like the PDP-10 JSP
instruction, something that jumps to a subroutine and puts the return
address in a register instead of on the stack.  It should cut the
penalty of a subroutine call in about half.  This would really help out
many kinds of compilers in that the trade-off between putting stuff
in-line and calling a short subroutine would be changed in favour of the
subroutine.

        These are things I would very much like to see.  There are
others that I wouldn't mind at all, but they aren't very important
compared to the two above.

        I would guess that this would be a case for inviting discussion
from the net rather than telling people to mail to me, but as I said
above, I'm very new at this, so please use your judgment (and tell me if
I was wrong, I'm willing to learn).
-- 
Gunnar Blomberg (Grzm), Computing Science Dept., Uppsala University, Sweden
Tel: +46 18 13 76 02
UUCP: grzm@kuling.UUCP (...!{seismo,mcvax}!enea!kuling!hans)