lab1: machine language and assembly programming

Lab1: Machine Language and

Assembly Programming

Dimitar Nikolov

Lund University / Electrical and Information Technology / 1

Goal

• Learn how to write an assembly program for a MIPS

architecture

• Understand how instructions are executed

• Understand the usage of the Program Counter (PC) register

• Where data and instruction reside during program execution


Tools

• Tools used for this exercise:

– MipsIt.exe

– Mips.exe

Used for program editing

Used for simulation


Online test

• The online test is scheduled on Monday 04th November

• Access the test from the course web-page

• Example of an online test will be provided soon


Overview

• Background

• MIPS architecture

• Writing an assembly program for a MIPS architecture

• Writing an assembly program using MipsIT toolset


Programmers vs. computers

• Programmers can write programs in a high-level language,

or assembly language

• Computers can only execute programs written in their own

native language (machine code)


Programming

High-level language (we don’t need to know the architecture)

Machine language (native to

the architecture)

Assembly language (we need to know the architecture)


Machine Language

• CPU can only execute machine instructions

• The instructions reside in memory along with data

• Machine instruction is a sequence of bits

• There is a set of machine instructions that are supported

by a given computer architecture (Instruction Set)

00001

Opcode Operand (register) Operand (minne)

011 101010111101110


Instruction Set

• Type of instructions

– Arithmetic and logic (ALU)

– Data transfer

– Branch

– I/O

• Considerations:

– Type of operands and operations

– Where operands reside (registers or memory)

– Addressing modes (direct, immediate, indirect, etc.)

– Instruction format (fixed length vs. variable length)


Overview

• Background





MIPS architecture

• A register file which consists of 32 general-purpose

(programmer visible) 32-bit registers

• Registers are denoted as $0-$31

• Register $0=0, is a constant (can not be modified by the

programmer)

• Register $31 is used to store the return address

• Special registers Lo and Hi, not directly accessible by the

programmer, are used to store result of multiplication or

division


MIPS architecture

• All instructions have the same length (32-bits)

• Three instruction formats:

op rs rt rd shamt funct

6 bits 6 bits 5 bits 5 bits 5 bits 5 bits

op rs rt constant or address

6 bits 5 bits 5 bits 16 bits

op address

6 bits 26 bits


MIPS architecture

• Register addressing: – All operands are registers

• Immediate addressing: – An operand is embedded within the instruction

• Displacement addressing: – Memory address is specified as an offset from a register

• PC-relative addressing: – Memory address is specified as an offset relative to the incremented PC

• Pseudodirect addressing: – Memory address is (mostly) embedded in the instruction

• Register direct addressing: – Memory address is stored in a register


MIPS architecture

• Examples:

ADD $8, $9, $10 ($8=$9+$10)

ANDI $8, $9, 0xFFFF ($8=$9 & 0xFFFF)

000000 01001 01010 01000 00000 100000

6 bits 6 bits 5 bits 5 bits 5 bits 5 bits

001100 01001 01000 1111111111111111

6 bits 5 bits 5 bits 16 bits

Register addressing

Immediate addressing


MIPS architecture

• Example: Displacement addressing

LW $8, 4($9) ($8=mm($9+4))

100011 01001 01000 0000000000000100

+

$7

$8 15862

$9 16

$10

16 ????

20 15862

24 ????

28 ????

16

4

20

registers

memory


Overview

• Background





Assembly programming

• Assembly instructions (mnemonic) for each machine

instruction

ADD $8, $9, $10 == 0x12A4020

• Pseudoinstructions (supported by assembler)

– Translated into a sequence of machine instructions

LW $8, data == LI $9, 0x85000

LW $8, 0($9)



• Program structure

– Plain text file with data declaration and program code

– Data declarations

• Starts with assembly directive .data

• Var_name: storage_type value(s) *examples will be provided

– Program code

• Starts with assembly directive .text

• Contains instructions

• Definition of starting and ending point of the program

– Additional assembly directives might be used prior the data

declaration segment



• ASSIGNMENT 1: Write an assembly program that

computes the N-th element in a Fibonacci sequence, and

stores the result in memory . Assume N>2

– Inputs: N (a memory location)

– Outputs: Y (a memory location)

• Example:

• Solution is given in Assignment1.pdf (course web-page)

0

1

0

1

21

F

F

FFF nnn

55 YN


Assignment 1



• ASSIGNMENT 2: Write an assembly program that counts

how many times a sequence of K ‘1’s exists in a given

number N, and stores the result in memory

– Inputs: K, N

– Outputs: Y

• Example: K=2, N=0x0FD55 => Y=5

• Solution is given in Assignment2.pdf (course web-page)

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 1 0 1 0 1 0 1 0 1

1 1

1 1

1 1

1 1

1 1


Assignment 2


Overview

• Background





Assembly programming using MipsIt toolset

• Open MipsIt.exe



• Create a new Assembler project



• Create a new Assembler file



• Write the assembly program



• Compile the assembly program



• Build the executable code



• Open Mips.exe



• Load the program in the simulator



Click to see and change the

values of the registers

Click to see and change the values at

different memory locations



Code segment

Data segment



• In the Memory window, double-click the memory location

which is right bellow the last instruction in the program

code



• Execute the program

• To execute the last instruction, you need to Step run



• For a better understanding on how the execution flows use

the Step option

• By stepping, you get to see how the code is executed

instruction after instruction

lab1: machine language and assembly programming

Documents