Filter
Top Products
INTRODUCTION
eliminates the need to "shuffle" intermediate
results back and forth between memory and
the accumulator, thus improving processing
speed and efficiency.
Program Counter (Jumps, Subroutines and
the Stack):
The instructions that make
up
a program are
stored
in
the system's memory. The central
processor references the contents
of
mem-
ory in order to determine what action is
appropriate. This means that the processor
must know which
location contains the next
instruction.
Each of the
locations in memory
is
numbered, to distinguish it from all other
locations in memory. The number which
identifies a memory
location
is
called its
Address. The processor maintains a counter
which contains the address
of
the next
program instruction. This register is called
the Program Counter. The processor up-
dates the program counter by adding
"1" to
the counter each time it fetches
an
instruction, so that the program counter
is
always current (pointing to the next instruc-
tion).
The programmer therefore stores his instruc-
tions in
numerically adjacent addresses, so
that the
lower addresses contain the first
instructions to be executed and the higher
addresses contain
later instructions. The
only time the progrl:immer may violate this
sequential rule is when
an
instruction in one
section of memory
is
a Jump instruction to
another section
of
memory.
A
jump
instruction contains the address
of
the instruction which
is
to follow
it.
The next
instruction may be stored in any memory
location,
as
long
as
the programmed jump
specifies the correct address. During the
execution of a jump instruction, the proces-
sor
replaces the contents
of
its program
counter with the address embodied in the
Jump. Thus, the
logical continuity
of
the
program
is
maintained.
A
special kind
of
program jump occurs when
the stored program
"Calls" a subroutine.
In
1·6
this kind
of
jump, the pJOcessor
is
required to
"remember" the contents
of
the program
counter at the time that the jump occurs. This
enables the processor to resume execution
of
the main program when it
is
finished with
the
last instruction
of
the subroutine.
A Subroutine
is
a program within a program.
Usually it
is
a general-purpose set
of
instructions that must be executed repeat-
edly
in
the course
of
a main program.
Routines which
calculate the square, the
sine,
or
the logarithm of a program variable
are good examples
of
functions often written
as
subroutines. Other examples might be
programs designed for inputting data to a
particular peripheral device.
The processor has a
special way of handling
subroutines, in order to insure
an
orderly
return to the main program. When the
processor receives a
Call instruction, it
increments the Program Counter and stores
the counter's contents in a reserved memory
area known
as
the Stack. The Stack thus
saves the address of the instruction to be
executed after the subroutine
is
completed.
Then the processor loads the address
specified in the
Call into its Program Counter.
The next instruction fetched will therefore be
the first step of the subroutine.
The
last instruction in any subroutine
is
a
Return. Such
an
instruction need specify no
address. When the processor fetches a
Return instruction, it
simply replaces the
current contents
of
the Program Counter
with the address on the top
of
the stack. This
causes the processor to resume execution
of
the calling program
at
the point immediately
following
the original Call instruction.
Subroutines are often Nested; that
is,
one
subroutine
will sometimes call a second
subroutine. The second may
call a third, and
so on. This
is
perfectly acceptable,
as
long
as
the processor
has
enough capacity to store
the necessary return addresses, and the
logical provision for doing
so.
In
other words,
the maximum depth
of
nesting
is
determined
by the depth
of
the stack itself. If the stack has
space for storing three return addresses, then