You are here: Home » Content » Instruction Set: Characteristics and Functions
Content Actions

Instruction Set: Characteristics and Functions

Module by: Nguyen Thi Hoang Lan

Summary: This module present the intruction set, the functions, the types of operands and of operations. The module focuses on the Instruction Set: Characteristics and Functions.

Machine Instruction Characteristics

What is an Instruction Set?
From the designer's point of view, the machine instruction set provides the functional requirements for the CPU: Implementing the CPU is a task that in large part involves implementing the machine instruction set. From the user's side, the user who chooses to program in machine language (actually, in assembly language) becomes aware of the register and memory structure, the types of data directly supported by the machine, and the functioning of the ALU.
Elements of an Instruction
Each instruction must have elements that contain the information required by the CPU for execution. These elements are as follows
  • Operation code: Specifies the operation to be performed (e.g.. ADD, I/O). The operation is specified by a binary code, known as the operation code, or opcode.
  • Source operand reference: The operation may involve one or more source operands, that is, operands that are inputs for the operation.
  • Result operand reference: The operation may produce a result.
  • Next instruction reference: This tells the CPU where to fetch the next instruc­tion after the execution of this instruction is complete.
The next instruction to be fetched is located in main memory or, in the case of a virtual memory system, in either main memory or secondary memory (disk). In most cases, the next instruction to be fetched immediately follows the current instruction. In those cases, there is no explicit reference to the next instruction. Source and result operands can be in one of three areas:
  • Main or virtual memory: As with next instruction references, the main or vir­tual memory address must be supplied.
  • CPU register: With rare exceptions, a CPU contains one or more registers that may be referenced by machine instructions. If only one register exists, reference to it may be implicit. If more than one register exists, then each register is assigned a unique number, and the instruction must contain the number of the desired register.
  • I/O device: The instruction must specify (he I/O module and device for the operation. If memory-mapped I/O is used, this is just another main or virtual memory address.
Instruction Cycle State Diagram
Figure 1
Instruction Representation
Within the computer, each instruction is represented by a sequence of bits. The instruction is divided into fields, corresponding to the constituent elements of the instruction. During instruction execution, an instruction is read into an instruction register (IR) in the CPU. The CPU must be able to extract the data from the various instruction fields to perform the required operation.
It is difficult for both the programmer and the reader of textbooks to deal with binary representations of machine instructions. Thus, it has become common prac­tice to use a symbolic representation of machine instructions. Opcodes are represented by abbreviations, called mnemonics, that indicate the operation. Common examples include
ADD Add
SUB Subtract
MPY Multiply
DIV Divide
LOAD Load data from memory
STOR Store data to memory
Operands are also represented symbolically. For example, the instruction
ADD R, Y
may mean add the value contained in data location Y to the contents of register R. In this example. Y refers to the address of a location in memory, and R refers to a particular register. Note that the operation is performed on the contents of a loca­tion, not on its address.
Simple Instruction Format
Figure 2
Instruction Types
Consider a high-level language instruction lhal could be expressed in a language such as BASIC or FORTRAN. For example,
X = X+Y
This statement instructs the computer lo add the value stored in Y to the value Stored in X and put the result in X. How might this be accomplished with machine instructions? Let us assume that the variables X and Y correspond lo locations 513 and 514. If we assume a simple set of machine instructions, this operation could be accomplished with three instructions:
  1. Load a register with the contents of memory location 513.
  2. Add the contents of memory location 514 to the register.
  3. Store the contents of the register in memory location 513.
As can be seen, the single BASIC instruction may require three machine instructions. This is typical of the relationship between a high-level language and a machine language. A high-level language expresses operations in a concise algebraic form, using variables. A machine language expresses operations in a basic form involving the movement of data to or from registers.
With this simple example to guide us, let us consider the types of instructions that must be included in a practical computer. A computer should have a set of instructions that allows the user to formulate any data processing task. Another way to view it is to consider the capabilities of a high-level programming language. Any program written in a high-level language must be translated into machine language to be executed. Thus, the set of machine instructions must be sufficient to express any of the instructions from a high-level language. With this in mind we can cate­gorize instruction types as follows:
  • Data processing: Arithmetic and logic instructions
  • Data storage: Memory instructions
  • Data movement: I/O instructions
  • Control: Test and branch instructions
Number of Addresses
What is the maximum number of addresses one might need in an instruction? Evidently, arithmetic and logic instructions will require the most operands. Virtually all arithmetic and logic operations are either unary (one operand) or binary (two operands). Thus, we would need a maximum of two addresses to reference operands. The result of an operation must be stored, suggesting a third address. Finally, after com­pletion ol an instruction, the next instruction must be fetched, and its address is needed.
This line of reasoning suggests that an instruction could plausibly be required to contain four address references: two operands, one result and the address of the next instruction. In practice, four-address instructions are extremely rare. Most instructions have one, two, or three operand addresses, with the address of the next instruction being implicit (obtained from the program counter).
3 addresses
  • Operand 1, Operand 2, Result
Example: a = b + c
  • Three-address instruction formats are not common, because they require a rel­atively long instruction format to hold the three address references.
2 addresses
  • One address doubles as operand and result
Example: a = a + b
    • The two-address formal reduces the space requirement but also introduces some awkwardness. To avoid altering the value of an operand, a MOVE instruction is used to move one of the values to a result or temporary location before performing the operation.
  • 1 addresses
    • a second address must be implicit. This was common in earlier machines, with the implied address being a CPU register known as the accumulator. or AC. The accumulator contains one of the operands and is used to store the result.
  • 0 (Zero) addresses
    • Zero-address instructions are applicable to a special memory organization, called a Stack. A stack is a last-in-first-out set of locations.
How Many Addresses?
The number of addresses per instruction is a basic design decision.
Fewer addresses:
  • Fewer addresses per instruction result in more primitive instructions, which requires a less complex CPU.
  • It also results in instructions of shorter length. On the other hand, programs contain more total instructions, which in general results in longer execu­tion times and longer, more complex programs
Multiple-address instructions:
  • With multiple-address instructions, it is common to have multiple general-purpose registers. This allows some operations to be performed solely on registers.
  • Because register references are faster than memory references, this speeds up execution.
Design Decisions
One of the most interesting and most analyzed, aspects of computer design is instruction set design. The design of an instruction set is very complex, because it affects so many aspects of the computer system. The instruction set defines many of the functions performed by the CPU and thus has a significant effect on the imple­mentation of the CPU. The instruction set is the programmer's means of control­ling the CPU. Thus, programmer requirements must be considered in designing the instruction set. The most important design issues include the following:
  • Operation repertoire: How many and which operations to provide, and how complex operations should be
  • Data types: The various types of data upon which operations are performed
  • Instruction format: Instruction length (in bits), number of addresses, size of various fields, and so on.
  • Registers: Number of CPU registers that can be referenced by instructions, and their use.
  • Addressing: The mode or modes by which the address of an operand is specified

Types of Operands

Machine instructions operate on data. The most important general categories of data are:
  • Addresses
  • Numbers
  • Characters
  • Logical data
Numbers
All machine languages include numeric data types. Even in nonnumeric data pro­cessing, there is a need for numbers to act as counters, field widths, and so forth. An important distinction between numbers used in ordinary mathematics and num­bers stored in a computer is that the latter are limited. Thus, the programmer is faced with understanding the consequences of rounding, overflow and underflow.
Three types of numerical data are common in computers:
  • Integer or fixed point
  • Floating point
  • Decimal
Characters
A common form of data is text or character strings. While textual data are most con­venient for human beings, they cannot, in character form, be easily stored or trans-milted by data processing and communications systems. Such systems are designed for binary data. Thus, a number of codes have been devised by which characters are represented by a sequence of bits. Perhaps the earliest common example of this is the Morse code. Today, the most commonly used character code in the International Reference Alphabet (IRA), referred to in the United Slates as the American Stan­dard Code for Information Interchange (ASCII). IRA is also widely used outside the United States. Each character in this code is represented by a unique 7-bit pattern, thus, 128 different characters can be represented. This is a larger number than is necessary to represent printable characters, and some of the patterns represent control characters. Some of these control characters have to do with controlling the printing of characters on a page. Others are concerned with communications procedures. IRA-encoded characters are almost always stored and transmitted using 8 bits per character. The eighth bit may be set to 0 or used as a par­ity bit for error detection. In the latter case, the bit is set such that the total number of binary 1s in each octet is always odd (odd parity) or always even (even parity).
Another code used to encode characters is the Extended Binary Coded Dec­imal Interchange Code (EBCDIC). EBCDIC is used on IBM S/390 machines. It is an 8-bit code. As with IRA, EBCDIC is compatible with packed decimal. In the case of EBCDIC, the codes 11110000 through 11111001 represent the digits 0 through 9.
Logical Data
Normally, each word or other addressable unit (byte, half-word, and soon) is treated as a single unit of data. It is sometimes useful, however, to consider an n-bit unit as consisting 1-bit items of data, each item having the value 0 or I. When data are viewed this way, they are considered to be logic data.
There are two advantages to the bit-oriented view:
  • First, we may sometimes wish to store an array of Boolean or binary data items, in which each item can take on only the values I (true) and II (fake). With logical data, memory can be used most efficiently for this storage.
  • Second, there are occasions when we wish to manipulate the bits of a data item.

Pentium Data Types

The Pentium can deal with data types of 8 (byte), 16 (word), 32 (double-word) and 64 (quad-word) bits in length.
  • Addressing is by 8 bit unit
  • A 32 bit double word is read at addresses divisible by 4
Specific Data Types
  • General - arbitrary binary contents
  • Integer - single binary value
  • Ordinal - unsigned integer
  • Unpacked BCD - One digit per byte
  • Packed BCD - 2 BCD digits per byte
  • Near Pointer - 32 bit offset within segment
  • Bit field
  • Byte String
  • Floating Point
Pentium Numeric Data Formats
Figure 3

PowerPC Data Types

The PowerPC can deal with data types of 8 (byte). 16 (half-word), 32 (word), and 64 (double-word) bits in length. Some instructions require that memory operands be aligned on a 32-bit boundary. In general, however, alignment is not required. One interesting feature of the PowerPC is that it can use either little-endian or big-endian style; that is, the least significant byte is stored in the lowest or highest address.
The byte, half-word, word, and double-word are general data types. The proces­sor interprets the contents of a given item of data depending On the instruction. The fixed-point processor recognizes the following data types:
  • Unsigned byte: Can be used for logical or integer arithmetic operations, it is loaded from memory into a general register by zero extending on the left to the full register size.
  • Unsigned half word: As for unsigned byte, but for 16-bit quantities.
  • Signed half-word: Used for arithmetic operations; loaded into memory by sign extending on the left to full register size (i.e., the sign bit is replicated in all vacant positions).
  • Unsigned word: Used for logical operations and as an address pointer.
  • Signed word: Used for arithmetic operations.
  • Unsigned double-word: Used as an address pointer.
  • Byte string: From 0 to 128 bytes in length.
In addition, the PowerPC supports the single and double-precision floating ­point data types defined in IEEE 754.

Types of Operations

The number of different opcodes varies widely from machine to machine. However, the same general types of operations are found on all machines. A useful and typi­cal categorization is the following:
  • Data transfer
  • Arithmetic
  • Logical
  • Conversion
  • I/O
  • System control
  • Transfer of control
Data transfer:
The most fundamental type of machine instruction is the data transfer instruction. The data transfer instruction must specify several things.
  • The location of the source and destination operands must be specified. Each location could be memory. a register, or the lop of the stack.
  • The length of data to be transferred must be indicated.
  • As with all instructions with operands, the mode of addressing for each operand must be specified.
In term of CPU action, data transfer operations are perhaps the simplest type. If both source and destination are registers, then the CPU simply causes data to be transferred from one register to another; this is an operation internal to the CPU. If one or both operands are in memory, then (he CPU must perform some or all of following actions:
  1. Calculate the memory address, based on the address mode
  2. If the address refers to virtual memory, translate from virtual to actual mem­ory address.
  3. Determine whether the addressed item is in cache.
  4. If not, issue a command lo the memory module.
Example:
Operation mnemonic Name Number of bits transferred Description
L Load 32 Transfer from memory in register
LH Load half-word 16 Transler from memory to register
ST Store 32 Transfer from register to memory
STH Store half-word 16 Transfer from register to memory
Arithmetic
Most machines provide the basic arithmetic operations of add, subtract, multiply, and divide. These are invariably provided for signed integer (fixed-point) numbers, Often they are also provided for floating-point and packed decimal numbers.
Other possible operations include a variety of single-operand instructions: for example.
  • Absolute: Take the absolute value of the operand.
  • Negate: Negate the Operand.
  • Increment.: Add 1 to the operand.
  • Decrement: Subtract 1 from the operand
Logical
Most machines also provide a variety of operations for manipulating individual bits of a word or other addressable units, often referred to as "bit twiddling." They are based upon Boolean operations.
Some of the basic logical operations that can be performed on Boolean or binary data are AND, OR, NOT, XOR, …
These logical operations can be applied bitwise to n-bit logical data units. Thus, if two registers contain the data
(R1) - 10100101 (R2) - 00001111
then
(R1) AND (R2) – 00000101
In addition lo bitwise logical operations, most machines provide a variety of shifting and rotating functions such as shift left, shift right, right rotate, left rotate…
Figure 4
Conversion
Conversion instructions are those that change the format or operate on the format of data. An example is converting from decimal to binary. An example of a more complex editing instruction is the S/390 translate (TR) instruction. This instruction can be used lo convert from one 8-bit code to another, and it takes three operands:
TR R1,R2,L
The operand R2 contains the address of the start of a table of 8-bit codes. The L bytes starting at the address specified in R1 are translated, each byte being replaced by the contents of a table content entry indexed by that byte. For example, to translate from EBCDIC to IRA, we first create a 256-byte table in storage locations, say 1000-l0FF hexadecimal. The table contains the characters of the IRA code in the sequences the binary representation of the EBCDIC code; that is, the IRA code is placed in the table at the relative location equal to the binary value of the EBCDIC code of the same character. Thus, locations 10F0 through IUF9 will contain the values 30 through 39, because F0 is the EBCDIC code for the digit 0, and 30 is the IRA code for the digit 0, and so on through digit 9. Now suppose we have the EBCDIC for the digits 1984 Starting at location 2100 and we wish to translate to IRA. Assume Ihe following:
  • Locations 2100-2103 contain Fl F9 F8 F4
  • R1 contains 2100.
  • R2 contains 1000.
Then, if we execute
TR R1,R2,4
locations 2100-2103 will contain 31 39 3S 34.
Input/Output
As we saw, there are a variety of approaches taken, including isolated programmed IO, memory-mapped programmed I/O, DMA, and the use of an I/O processor. Many implementations provide only a few I/O instructions, with the specific actions spec­ified by parameters, codes, or command words.
System Controls
System control instructions are those that can he executed only while the proces­sor is in a certain privileged state or is executing a program in a special privileged area of memory, typically, these instructions are reserved for the use of the oper­ating system.
Some examples of system control operations are as follows. A system control instruction may read or alter a control register. Another example is an instruction to read or modify a storage protection key, such us is used in the S/390 memory system. Another example is access to process control blocks in a multiprogramming system.
Transfer of control
For all of the operation types discussed so far. The next instruction to be performed is the one that immediately follows, in memory, the current instruction. However, a significant fraction of the instructions in any program have as their function chang­ing the sequence of instruction execution. For these instructions, the operation per­formed by the CPU is to update the program counter to contain the address of some instruction in memory.
There are a number of reasons why transfer-of-control operations are re­quired. Among the most important are the following:
  1. In the practical use of computers, it is essential to be able to execute each instruction more than once and perhaps many thousands of times. It may require thousands or perhaps millions of instructions to implement an appli­cation. This would be unthinkable if each instruction had to be written out sep­arately. If a table or a list of items is to be processed, a program loop is needed. One sequence of instructions is executed repeatedly to process all the data.
  2. Virtually all programs involve some decision making. We would like the com­puter to do one thing if one condition holds, and another thing if another con­dition holds. For example, a sequence of instructions computes the square root of a number. At the start of the sequence, the sign of the number is tested, If the number is negative, the computation is not performed, but an error con­dition is reported.
  3. To compose correctly a large or even medium-size computer program is an exceedingly difficult task. It helps if there are mechanisms for breaking the task up into smaller pieces that can be worked on one at a time.
We now turn to a discussion of the most common transfer-of-control opera­tions found in instruction sets: branch, skip, and procedure call.
Branch instruction
A branch instruction, also called a jump instruction, has as one of its operands the address of the next instruction to be executed. Most often, the instruction is a conditional branch instruction. That is, the branch is made (update program counter to equal address specified in operand) only if a certain condition is met. Otherwise, the next instruction in sequence is executed (increment program counter as usual).
There are two common ways of generating the condition to be tested in a condi­tional branch instruction. First, most machines provide a 1-bit or multiple-bit con­dition code that is set as the result of some operations. This code can be thought of as a short user-visible register. As an example, an arithmetic operation (ADD, SUB­TRACT, and so on) could set a 2-bit condition code with one of the following four values: 0. positive, negative, overflow. On such a machine, there could be four dif­ferent conditional branch instructions:
BRP X Branch to location X if result is positive.
BRN X Branch to location X if result is negative.
BRZ X Branch to location X if result is zero.
BRO X Branch lo location X if overflow occurs.
In all of these cases, the result referred to is the result of the most recent oper­ation that set the condition code.
Another approach that can be used with a three-address instruction formal is to perform a comparison and specify a branch in the same instruction, for example:
BRE Rl, R2, X Branch to X if contents of RI = contents of R2.
The Figure 5 shows examples of these operations. Note that a branch can be either forward (an instruction with a higher address) or backward (lower address). The example shows how an unconditional and a conditional branch can be used to create a repealing loop of instructions. The instructions in locations 202 through 210 will be executed repeatedly until the result of subtracting Y from X is 0.
Figure 5
Skip instructions
Another common form of transfer-of-control instruction is the skip instruc­tion. The skip instruction includes an implied address. Typically, the skip implies that one instruction be skipped; thus, the implied address equals the address of the next instruction plus one instruction-length.
Because the skip instruction does not require a destination address field, it is free to do other things. A typical example is the increment-and-skip-if-zero (ISZ) instruction. Consider the following program fragment:
301
.
.
.
  1. ISR R1
310 BR 301
311
In this fragment, the two transfer-of-control instructions are used to implement an iterative loop. Rl is set with the negative of the number of iterations to be per-formed. At the end of the loop, Rl is incremented. If it is not 0 I he program branches back lo the beginning of the loop. Otherwise, the branch is skipped, and the program continues with the next instruction after the end of the loop.
Procedure call instructions
Perhaps the most important innovation in the development of programming languages is the procedure, a procedure is a self-contained computer program that is incorporated into a larger program. At any point in the program the procedure may he invoked, or called. The processor is instructed to go and execute the entire procedure and then return to the point from which the call took place.
The two principal reasons for the use of procedures are economy and modu­larity. A procedure allows the same piece of code to be used many times. This is important for economy in programming effort and for making the most efficient use of storage space in the system (the program must be stored). Procedures also allow large programming tasks to be subdivided into smaller units. This use of modularity greatly eases the programming task.
The procedure mechanism involves two basic instructions: a call instruction that branches from the present location to the procedure, and a return instruction that returns from the procedure to the place from which it was called. Both of these are forms of branching instructions.
Figure 6
The above figure illustrates the use of procedures to construct a program. In this example, there is a main program starting at location 4000. This program includes a call to procedure PROC1, starting at location 4500. When this call instruction is encountered, the CPU suspends execution of the main program and begins ex­ecution of PROC1 by fetching the next instruction from location 4500. Within PROC1, there are two calls to PR0C2 at location 4800. In each case, the execution of PROC1 is suspended and PROC2 is executed. The RETURN statement causes the CPU to go back to the calling program and continue execution at the instruc­tion after the corresponding CALL instruction. This behavior is illustrated in the right of this figure.
Several points are worth noting:
  1. A procedure can be called from more than one location.
  2. A procedure call can appear in a procedure. This allows the nesting of proce­dures to an arbitrary depth.
  3. Each procedure call is matched by a return in the called program.
Because we would like to be able to call a procedure from a variety of points, the
CPU must somehow save the return address so that the return can take place appropriately. There are three common places for storing the return address:
  • Register
  • Start of called procedure
  • Top of stack
Consider a machine-language instruction CALL X. which stands for call procedure at location X. If the register approach is used, CALL X causes the following actions:
RN <- PC + ΔΔ size 12{Δ} {}
PC <- X
where RN is a register that is always used for this purpose, PC is the program counter, and A is the instruction length. The called procedure can now save the contents of RN to be used for the later return.
A second possibility is to store the return address at the start of the procedure. In this case, CALL X causes
X <- PC - ΔΔ size 12{Δ} {}
PC <- X + 1
This is quite handy. The return address has been stored safely away.
Both of the preceding approaches work and have been used. The only limitation of these approaches is that they prevent the use of reentrant procedures. A reentrant procedure is one in which it is possible to have several calls open to it at the same time. A recursive procedure (one that calls itself) is an example of the use of this feature.
A more general and powerful approach is to use a stack. When the CPU executes a call, it places the return address on the stack. When it executes a return, it uses the address on the stack. Below figure illustrates the use of the stack.
Figure 7
In addition to providing a return address, it is also often necessary to pass parameters with a procedure call, these can be passed in registers. Another possi­bility is to store the parameters in memory just after the CALL instruction. In this case, the return must be to the location following the parameters. Again, both of these approaches have drawbacks. If registers are used, the called program and the calling program must be written to assure that the registers are used properly. The storing of parameters in memory makes it difficult to exchange a variable number of parameters. Both approaches prevent the use of reentrant procedures.
A more flexible approach to parameter passing is the stack. When the proces­sor executes a call, it not only stacks the return address, it stacks parameters to be passed to (he called procedure. The called procedure can access the parameters from the slack. Upon return, return parameters can also he placed on the stack. The entire set of parameters, including return address, that is stored for a procedure invocation is referred to as a stack frame.
An example is provided in Figure 8.
Figure 8
The example refers to procedure P in which the local variables x1 and x2 are declared, and procedure Q which can be called by P and in which the local variables y1 and y2 are declared. In this figure, the return point for each procedure is the first item stored in the corresponding stack frame. Next is stored a pointer to the beginning of the previous frame. This is needed if the number or length of parameters to be stacked is variable.

Comments, questions, feedback, criticisms?

Send feedback