Abstractions and Computers and the MAL programming Language

1

Abstractions and Computers and the MAL programming

Language

2CMPE12c Cyrus Bazeghi

Computer Architecture

Definition: Interface between a computers hardware and its software. Defines exactly what the computer’s instructions do, and how they are specified.

Instruction Set Architecture (ISA)


MIPSmachine language

TALMALSAL

• SAL – Simple Abstract Language• MAL – MIPS Assembly Language• TAL – True Assemble Language



HighLevel

Language

AssemblyLanguage

MachineLanguage

Compiler Assembler

Compiler: A computer program that translates code written in a high level language into an intermediate level abstract language.



Computer Science

Definition: Fundamentally the study of algorithms and data structures.

Abstraction: Use of level of abstraction in software design allows the programmer to focus on a critical set of problems without having to deal with irrelevant details.


Procedure or Function

int average (a, b)begin

avg = (a+b)/2;

return (avg);end

main ()…x = 4;y = 2;k = average (x,y);print (“%d”, k);…

Computer Science


CPU(MIPS)

Computer

MemoryWrite data

Read data

Control info

CPU Interacts with the memory in 3 ways:• fetches instructions• loads the value of a variable• stores the new value of a variable

Memory is capable of only 2 operations:• reads – a load or a fetch• writes – operation of a storing the value of a variable



Instruction Fetch / Execute Cycle

In addition to input & output a program also:

•Evaluates arithmetic & logical functions to determine values to assign to variable.•Determines the order of execution of the statements in the program.

In assembly this distinction is captured in the notion of Arithmetic, logical, and control instructions.


Arithmetic and logical instructions evaluate variables and assign new values to variables.

Control instructions test or compare values of a variable and makes decisions about what instruction is to be executed next.

Program Counter (PC)Basically the address at which the current executing instruction exists.



1. load rega, 102. load regb, 203. add regc, rega, regb4. beq regc, regd, 85. store regd, rege6. store regc, regd7. load regb, 158. load rega, 30

PC


Address


The CPU begins the execution of an instruction by supplying the value of the PC to the memory & initiating a read operation (fetch).

The CPU “decodes” the instruction by identifying the opcode and the operands.

PC increments automatically unless a control instruction is used.



For example:

PC add A, B, C

o CPU fetches instructiono Decodes it and sees it is an add operation, needs to get values for the variables “B” & “C”o CPU executes a load operation, gives address of variable “B”o Does the same for variable “C”o Does the “add” operation and stores the result in location of variable “A”



Branch – like a goto instruction, next instruction to be fetched & executed is an instruction other than the next in memory.


add A, B, Cbeq A, 5, fredsub A, D, 3

fred: sub A, D, 4

If A==5 then next instruction is at fred


Breaking down an instruction

add a, b, c

a b cadd

Opcode

Destination register

Source registers


Locality of reference

We need techniques to reduce the instruction size. From observation of programs we see that a small and predictable set of variables tend to be referenced much more often than other variables.


Basically, locality is an indication that memory is not referenced randomly.

This is where the use of registers comes into play.


Registers and MAL

ALURegister

ArrayMemory CtrlData cacheInst. cache

IO

Memory(disk)

Program “code” is in memory (or cache), use registers to hold commonly used variables for faster execution


CISC vs. RISC

CISC : complex instruction set computerLots of instructions of variable size, very memory optimal, typically less registers.

RISC : reduced instruction set computerLess instructions all of a fixed size, more registers, optimized for speed. Usually a “Load/Store” architecture.


Specifying addresses

For a load/store architecture, registers are used to supply source operands and receive results from all instructions except loads and stores.

Basically, load the registers with the operands from memory first, then perform the operation.


How do we fit the “stuff” in 32-bit instructions?

So we have arithmetic instructions and branch type instructions that cannot contain all the needed info in a single 32-bit word.


opcode addressregreg Effective

address

2. Instruction might specify a register that contains the address, 1 word instruction.

1. Instruction might occupy 2 words.

opcode addressregEffectiveaddress

Ways to get an effective address


3. Instruction might specify a small constant and a second register, 1 word instruction.

opcode reg constant

addressreg + Effective address

Effective Address Calculation


4. The instruction might specify 2 additional registers, 1 word instruction.

opcode reg reg

addressreg addressreg

+

Effective address

Effective Address Calculation


Addressing modes

Methods a computer uses to specify an address within an instruction.


• ImmediateThe operand is contained directly in the instruction. Ex: li reg1, 5

• RegisterThe operand is contained in a register. Ex: add reg1, reg2, reg3

• DirectThe address of the operand is contained in the instruction (two-word instruction)

Addressing Modes


•Register DirectThe address of the operand is contained in a register. Ex: lw reg1, reg3

•Base DisplacementThe address is computed as the sum of the contents of a register (the base) and a constant contained in the instruction (the displacement). Ex: lw reg1, 5(reg3)

Addressing Modes


• IndirectThe instruction specifies a register containing an address the content of which is the address of the operand

opcode reg

address

address

reg

Effective address

Memoryaddress

Addressing Modes


MAL

2 distinct register files:

•32 general registers•16 floating point registers

(MIPS Assembly Language)

MIPS is a load/store RISC architecture


The 32 general registers are numbered $0 - $31.

$0 is always the value “Zero”.

$1 is used by the assembler.

$26 & $27 are used by the operating system.

$28, $29, & $31 have special conventions for the use of them.

MAL


Common aliases for registers

$2-$3 $v0-$v1 procedure results$4-$7 $a0-$a3 parameters for procedure$8-$15 $t0-$t7 temporary registers$24-$25 $t8-$t9$16-$23 $s0-$s7 saved registers$30 $s8$29 $sp stack pointer$31 $ra return address register


The 16 floating point registers are intended exclusively for holding floating point operands. These registers are 64-bits in size for holding both single precision (32-bit) floats and double precision (64-bit) floats.

These registers are named $f0, $f2, $f4,…., $f30.

Why?

MAL


MAL uses a single, versatile addressing mode for its regular load store .

Base displacement.

General since its special cases provide for both direct and register direct address.

MAL


MAL has 3 basic types:

IntegerFloating pointCharacter

Syntax of MAL

one instruction, declaration per linecomments are anything on a line following #comments may not span lines

MAL Syntax


“C”type variablename;

“MAL”variablename: type value

type is.word (integer).byte (character).float (floating point)

value is optional – the initial value

MAL Syntax


Examples:flag: .word 0counter: .word 0variable3: .worde: .float 2.71828uservalue: .byteletter: .byte ‘a’

•One declaration per line•Default initial value is 0(but you may lose points if you depend on this)

MAL Syntax


Directives give information to the assembler. All directives start with ‘.’ (period)

Examples:.byte.word.floatmain:

# tells simulator to start execution at this location..data

# .data identifies the start of the declaration section # there can be more than 1 .data sections in a program.

MAL Syntax


.text# identifies where instructions are, there can

be # more than 1 .text sections in a program

.asciiz “a string.\n” # places a string into memory and null

terminates# the string

.ascii “new string.”# places a string into memory with no null# termination.

MAL Syntax


MAL lw $s1, x lw $s2, y move $s3, $s2 add $s3, $s1, $s2 sub $s3, $s1, $s2 mul $s3, $s1, $s2 div $s3, $s1, $s2 rem $s3, $s1, $s2 sw $s3, z

C

z = y; z = x + y; z = x - y; z = x * y; z = x / y;

z = x % y;

An immediate is a value specified in an instruction, not in the .data section.Examples: li $s2, 0 # load immediate

add $s2, $s2, 3 # add immediate

MAL Syntax


Simple MAL program

.data avg: .word 0 i1: .word 20 i2: .word 13 i3: .word 2 .textmain:

lw $s1, i1 lw $s2, i2 lw $s3, i3 add $s4, $s1, $s2

div $s4, $s4, $s3 sw $s4, avg li $2, 10 # done cmd syscall

MAL Program


•Assembler translates to executable – machine language•Linker combines multiple MAL files – if any•Loader puts executable into memory and makes the CPU jump to first instruction or “main:”•Executes•When executing is done returns control to OS

•Or simulator or monitor•Load again to run again with different data

•In this case, assemble again, too, since data is in program.

Program Execution


HLL – if/else statements…

if (condition) statement;

else statement;

“C” if (count < 0) count = count + 1;

MAL Programming


“MAL” lw $t1, countbltz $t1, ifstuffb endif

ifstuff: add $t1, $t1, 1 endif: # next instruction goes here

“OR” lw $t1, countbgez $t1, endifadd $t1, $t1, 1

endif: # next instruction goes here

MAL Programming


Loops can be built out of IF’s – WHILE:

“C” while (count > 0)

{a = a % count;

count--;}

MAL Programming


“MAL”

lw $s1, countlw $s2, a

while: blez $s1, endwhilerem $s2, $s2, $s1sub $s1, $s1, 1b while

endwhile: sw $s2, asw $s1, count

MAL Programming


Repeat loops

“C”/* do statement while expression is TRUE *//* when expression is FALSE, exit loop */do {

if (a < b)a++;

if (a > b)a--;

} while (a != b)

MAL Programming


“MAL”lw $s3, alw $s4, b

repeat: bge $s3, $s4, secondifadd $s3, $s3, 1

secondif: ble $s3, $s4, untilsub $s3, $s3, 1

until: bne $s3, $s4, repeat

MAL Programming


While Loops (Part II)

“C”while ( (count < limit) && (c ==d) )

{ /* loop’s code goes here */}“MAL”

while: ??

# loop code goes here ?

endwhile:

MAL Programming


For loops

“C”for ( I = 3; I <= 8; I++)

{ a = a+I;}“MAL”

?for: ?

???

endfor:

MAL Programming


Procedure Calls

Simple procedure calls require 2 instructions:

“JR” Jump Register•Be careful with registers!!•Cannot nest unless $ra is saved elsewhere•Cannot be recursive without a stack

“JAL” Jump and Link•Link means save the return address in $ra ($31)


MAL Procedures

jal average # calls proc.

…

average: add $s2, $s3, $s4div $s2, $s2, 2jr $ra # returns

Example


Operating System Calls

Use $2 ($v0) to pass code to OSUse $4 ($a0) to pass data to OSUse “syscall” instruction to call OS

Very tedious and dangerous for a programmer to deal with IO. This is why we like to have an OS. Need an

instruction though to get its attention.


Code ($v0) Function Usage & Result

1 Print Integer Put integer in $a0

2Print Float

Put floating point number in $f12

3 Print Double Put double in $f12

4 Print String Put address of string into $a0

5 Read Integer Returns integer read in $v0

6 Read Float Returns float read in $f0

7 Read Double Returns double read in $f0

8Read String

Put address in $a0, length in $a1

10 Exit Quits program

11 Print Character

Put character in $a0

12 Get Character Returns character in $v0

Operating System Codes


To print a character# address of the char must be in $s0lb $a0, ($s0)# $4 char to be printedli $v0, 11 # code for putcsyscall

To read in a character

li $v0, 12 # code for getcsyscall # character returned

# in $v0

SYS Calls Examples


To end your program

li $v0, 10 # code for donesyscall

SYS Calls Examples

Abstractions and Computers and the MAL programming Language

Documents

goto instruction

c cpu fetches instruction

variable memory

variable c

current executing instruction

read operation fetch

pcinstruction fetch

load operation