Intel MCS48 User Manual page 24

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
programmer 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
this
kind
of
jump, the processor
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
1-6