Language of Computer - by Quek Xin Yi

Operations of The Computer Hardware

•  Every computer must be able to perform arithmetic. Here, MIPS instruction set is used as example.
•  MIPS assembly language notation:

            add a, b, c       #  a = b + c (in c code)            ** all arithmetic operations have this form.

•  The words to the right of the # symbol is meant for human reader(or known as comment), the computer will ignore them.
•   This language(MIPS) can contain at most one instruction, and must exactly three operand.

Example 1:

• In C code, given, a= b + c + d + e.
• In MIPS, is written as:

add a, b, c       # sum of b and c is placed in a.

add a, a, d       #sum of b, c, and d is placed in a

add a, a, e        #sum of b, c, d, and e is placed in a

Example 2:

·          Given in C code, f = (g+h)-(i+j)

·         Then, in MIPS compiled code :

add t0, g, h      # temp t0 = g + h

add t1, i, j        # temp t1 = I + j

sub f, t0, t1      # f = t0 – t1

• This shows that the MIPS language will only do one process in a time.

·         This situation illustrates the first of four underlying principles of hardware design:

-          Design principle 1:  simplicity favors regularity.

Operands of Computer hardware

Register operand

·         Operand of arithmetic instruction of MIPS must be from a limited number of special locations built directly in hardware, called registers.

·         Registers are primitives used in hardware design that are also visible to the programmer when the computer is completed.

·         The size of a register in MIPS architecture is 32 bits, they are given name, word.

·         The difference between the variables of a programming language and registers is limited number of registers, that is 32, as the second of four underlying design principle state that smaller is faster.

-Large number of register may increase the clock cycle time because it takes electronic signals longer when they must travel farther.

·         Register is represented by two-character names following a dollar sign, for example, $s0, $s1, $t0, $t1… etc.

·         The syntax is written as:

op  rd  rs1  rs2

op = operation

rd = registered destination

rs 1 and rs 2 = register source 1 and 2

Example:

 f = (g + h) – ( i + j)

add $t0, $s1, $s2                  # this instruction means $t0 = x , $s1 = g , $s2 = h, x = g + h

add $t1, $s3, $s4                  # this instruction means $t1 = y , $s3 = i , $s4 = j , y = i + j

sub $s0, $t0, $t1                   # this instruction means $s0 = f , $t0 = x , $t1 = y , f  = x + y

Memory Operands

·         Programming languages also have more complex data structures-arrays and structures which can contain many more data elements than there are registers in computer.

·         These complex data structures are kept in memory.

·         MIPS enable transfer data between memory and register, this is called data transfer instructions.

·         To access words in memory, instruction must supply the memory address.

·         Memory is just a large, single-dimensional array, with address acting as index to the array, starting at 0.

·         The instruction that copy data from memory to a register is called load.

·         Format writing load instruction: (actually MIPS name for it is lw, load word)

-operation name(lw), then register to be loaded (eg: $s1), then constant and register used to access memory.

·         Sum of constant portion of instruction and contents of the second register forms memory address.

·         The compiler allocates data structures to locations in memory, so that it can place proper starting address into the data transfer instructions.

·         In MIPS, words must start at addresses that are multiples of 4, this is called alignment restriction.

·         This instruction complementary to load is call store, which copy data from a register to memory.

·         The actual name in MIPS is sw, store word.

·         If a data is not exist in main memory, it must be load to the register, after having the result from register, store it in memory.

·         Example:

A[12] = h + A[8]

index 8 require 32 offset, multiply it by 4 as there are 4 bytes per word.

lw   $t0, 32 ( $s3 )       #load word

add $t0, $s2, $t0

sw  $t0, 48 ( $s3)        #store word

Constant/ immediate operands

·         The constant is added. For example, 1,2,3 etc.

·         The quick add instruction with one constant operand is called add immediate or addi.

·         There is no subi.

Example1 :

x = y + 4

written as, addi  $s3, $s3, 4    # first $s3= x, second $s3 = y

Example2:

x = y – 1

since there is no subi, so it is written as :

addi  $s3, $s3, -1

·         Immediate instructions illustrate the third design principle, make the common fast.

-small constants are common.

-immediate operand avoid load instruction.

Signed and unsigned numbers

·         Computer only read numbers of based two, or, binary digits.

·         Example : 1011 based2 equal to 11 based10.

·         The number of bits are numbered from right to left.

16   15  14   13	12   11   10   9	8    7    6    5	4    3    2    1
0    0    0    0	0    0    0    0	0    0    0    0	1   0    1    1

Unsigned binary integers

            x = x_n-12^n-1 + x_n-22^n-2 + … + x₁2¹ + x₀2⁰

·         Numbers have infinite number of digit, with almost all 0, except for a few of the rightmost digits.

·         Hardware designed to add, subtract, multiply and divide. If the number cannot be represented by these rightmost hardware bits, overflow occur.

Signed Binary Integers

·         Leading 0s means positive, whereas leading 1s means negative. This convention is called two’s complement representation.

·        x = - x_n-12^n-1 + x_n-22^n-2 + … + x₁2^x + x₀2⁰

·         After converting the 0 to 1, 1 to 0, add the words by 1.

·         For example:

+1 = 0000 0000 0000 0000 0000 0000 0000 0001

In order to get -1, convert it to 1111 1111 1111 1111 1111 1111 1111 1110, then add 1.

So, -1= 1111 1111 1111 1111 1111 1111 1111 1111

Reference:

Computer Organization and Design, by David A. Patterson, John L. Hennessy

Written by,
Quek Xin Yi
B031210203