Transcript Instructions - La Salle University

Instructions
Portability
• In addition to making hardware backward compatible, we
have also made software portable.
• In describing software, “portable” means that the software
can be run on a variety of computers. Another term used is
independence, in this case machine or hardware
independence. Assembly’s use of specifics of the registers
makes it machine dependent.
• One has to program at a higher level to gain machine
independence.
• Of course, someone must deal with the specifics of the
hardware but it doesn’t have to be you (Layering).
High-level language
• Languages which are above assembly language,
known as high-level languages, hide the details of
the hardware and thus are portable or hardware
independent.
• Of course, high-level language are not directly
executed. There is an in-between process or
processes (compiling, translating, interpreting,
linking, etc.) necessary before they can be executed.
CSIT 301 (Blum)
3
CSIT 301 (Blum)
4
Generations
• Another way of discussing this is to talk
about
generations.
• 1GL or first-generation language is machine
language.
• 2GL or second-generation language is assembly.
• 3GL or third-generation language is a "highlevel" programming language, Fortran, C, Java,
Visual Basic, etc.
• 4GL or fourth-generation language is a more
descriptive language, closer to human language
usually used to query databases.
CSIT 301 (Blum)
5
5th Generation Language
CSIT 301 (Blum)
6
Instruction Set
• One aspect of processor design
is to determine what instructions will be
supported.
• There must be rules (syntax) for how
instructions are expressed, so that the code
can be parsed, one instruction
distinguished from the next, the data
(operand) separated from the action
(operator).
CSIT 301 (Blum)
7
Number of operands
• An example of syntax would be whether an
operator is binary or unary
• Binary operators take two operands
– e.g. the Boolean operator AND
– (x<y) AND (i=j)
• Unary operators take one operand
– E.g. the Boolean operator NOT
– NOT(x<y)
• Some ops are context dependent
– - 5 (unary) versus 4-5 (binary)
CSIT 301 (Blum)
8
Operation versus Instruction
• An operation such as addition, which is
binary (takes two operands), can be coded
using instructions that are unary (one
operand) if there is a default location
implied such as Accumulator A.
• 5 + 6 becomes
– Load 5 (places data in acc. A)
– Add 6 (adds number in Acc. A to new number)
CSIT 301 (Blum)
9
Where does the answer go?
• Whether it’s 5 + 6 or (Load 5, Add 6),
there’s the question of what to do with the
result.
• We can again use the default location of
Accumulator A to place the answer in, or
we can include a third operand
that indicates where the result
should be placed.
CSIT 301 (Blum)
10
Store
• Placing the result of an operation in memory is
known as storing it. Thus with unary instructions,
we would have
– Load 5
– Add 6
– Store 7
• The operand of the store is an address indicating
where to store the answer, which is held in
Accumulator A.
• Or one might have just one instruction with three
operands
– Add 7, 5, 6
CSIT 301 (Blum)
11
Addressing Modes
• The “7” in the previous example was clearly an
address. But this raises the question as to
what were the operands in the two previous
instructions (Load and Add).
• For those instructions, the operand might
have been the actual numbers one wanted
added or the addresses of numbers one
wanted added.
CSIT 301 (Blum)
12
More than one kind of add
• By “Add” one typically means the latter case
on the previous slide. The operand is not the
number to be added but the address of the
number to be added.
– (Think variables.)
• A designer can include a distinct add
instruction, Add Immediate, in which the
operand is the actual number to be added.
CSIT 301 (Blum)
13
Add Indirect
• In another version of addition, the operand is
an address, and the data at that address is
also an address, and the actual number to be
added is located at the second address.
CSIT 301 (Blum)
14
A short program
Address
Value
0
LOAD 4
1
ADD INDIRECT 5
2
ADD IMMEDIATE 6
3
STOP
4
5
5
6
6
7
7
8
CSIT 301 (Blum)
Acc. A: XXX
The arrow indicates the
program counter, we
assume it has not
executed the statement it
points to.
15
A short program
Address
Value
0
LOAD 4
1
ADD INDIRECT 5
2
ADD IMMEDIATE 6
3
STOP
4
5
5
6
6
7
7
8
CSIT 301 (Blum)
Acc. A: 5
The Load 4 instruction
has been executed.
The value at location 4
(which is a 5) has
been loaded into the
accumulator.
16
A short program
Address
Value
0
LOAD 4
1
ADD INDIRECT 5
2
ADD IMMEDIATE 6
3
STOP
4
5
5
6
6
7
7
8
CSIT 301 (Blum)
Acc. A: 12
The Add Indirect 5 instruction
has been executed. One goes
to location 5 to find a value of
6. That 6 is an address, thus
one goes to location 6 to find a
value of 7 and that is added to
the 5 waiting in the
accumulator. The result of 12
is placed in the accumulator.
17
A short program
Address
Value
0
LOAD 4
1
ADD INDIRECT 5
2
ADD IMMEDIATE 6
3
STOP
4
5
5
6
6
7
7
8
CSIT 301 (Blum)
Acc. A: 18
The Add Immediate 6
instruction has been
executed. The value 6 is
data which is added to the
12 waiting in the
accumulator. The result of
18 is placed in the
accumulator.
18
The Stop Instruction
• Recall that in what is actually executed (machine
code, not assembly) the instructions themselves
are numbers.
• Thus it is crucial to know within a single
instruction which numbers correspond to an
operation and which numbers are operands.
• Similarly on the level of the program itself, the
processor needs to know where the program ends
as there may be data stored after it.
• In a machine with an operating system, it is more
a notion of returning (control) than of stopping or
halting.
CSIT 301 (Blum)
19
Recap so far
• So there were issues about the number of
operands.
– Recall that we have a fetch-execute cycle – first an
instruction is retrieved from memory and then acted
upon.
– With unary instructions adding two numbers and
storing the result required three instructions, that’s
three fetches and three executions.
– With ternary instructions it can be done with one
instruction, one fetch and one execute. The execution
is now more complicated but we have saved time on
fetches.
CSIT 301 (Blum)
20
Recap so far (Cont.)
• More operators means more complicated
circuitry, the load and store aspects of the
instruction would have to built into each
separate instruction.
• There is a speed versus complexity issue. And
complexity also brings the issue of cost along
with it.
CSIT 301 (Blum)
21
Recap so far (Cont.)
• After determining the number of operands, came
the issue of what the operands mean.
– Are they data, addresses of data, or addresses of
addresses of data?
• Either we can decide to support all of these types
of instructions (addressing modes) and choose
complexity. Or we can choose to support only
some of them and sacrifice efficiency.
– You can eliminate Add Immediate if you always store
the values you want to add.
CSIT 301 (Blum)
22
Data Types
• Apart from addressing, another issue is the type of
data the operation is acting on.
– The process for adding integers is different from the
process for adding floating point numbers.
– So one may have separate ADD and FADD for the addition
of integers and floats respectively.
– Furthermore, one may need to add instructions to convert
from one type to another.
• To add an integer to a float, convert the integer to a float and then
add the floats.
CSIT 301 (Blum)
23
References
• Computer Architecture, Nicholas Carter
• Digital Computer Electronics, Albert P.
Malvino and Jerald A. Brown
• http://www.webopedia.com
CSIT 301 (Blum)
24