CS代考计算机代写 assembler compiler assembly Java mips COMP273 McGill

COMP273 McGill
Assembler Arithmetic and Memory Access

• VariablesinAssembly
• AdditionandSubtractioninAssembly • Memory Access in Assembly
COMP273 McGill 2

Below Your Program • High-level language program (in C)
swap (int v[], int k) { int temp = v[k]; v[k] = v[k+1]; v[k+1] = temp;
• Assembly language program (for MIPS) swap: sll $2, $5, 2 add $2, $4,$2
C compiler
lw $15, lw $16, sw $16, sw $15, jr $31
• Machine (object) code (for MIPS)
0($2) 4($2) 0($2) 4($2)
000000 00000 00101 0001000010000000
000000 00100 00010 0001000000100000 …

Operators / Operands in High-level Languages
Operators: +, -, *, /, % ;
• 7/4==1, 7%4==3
• Variables: fahr, celsius
• Constants: 0, 1000, -17, 15.4
Statement: Variable = Expression ;
• celsius = 5*(fahr-32)/9; • a = b+c+d-e;
COMP273 McGill

Assembly Design: Key Concepts • Assemblylanguageisdirectlysupportedinhardware
• It is kept very simple!
– Limit on the type of operands
– Limit the set of operations to absolute minimum
COMP273 McGill 5

The MIPS Instruction Set
MIPS Technology
MARS: Free MIPS Simulator
How do I learn MIPS assembly?
• Microprocessor without Interlocked Pipelined Stages (MIPS) • Used MIPS32 as the example in this course (Quickguide)
• Download the software
• Run the software java –jar pMARS.jar
• Try it out with MARS!
COMP273 McGill

Assembly Variables: Register

Assembly Variables: Registers
C and Java
• Operands are variables and
• Declareasmanyasyouwant
• Variablesarereplaced
by registers
• Operations can only
be performed on these!
• Limited number built directly into the hardware
COMP273 McGill
Why? Keep the Hardware Simple!

Assembly Variables: Registers
• MIPS has a register file of 32 registers
• Why 32? Smaller is faster​
• Each MIPS register is 32 bits = 4 bytes = a word​
Register File
4-bit (General) Register
COMP273 McGill From previous lecture on “Register and Memory” 9

COMP273 McGill
Assembly Variables: Registers
Register file is small and inside of the core, so they are very fast
Since registers are implemented in the hardware, there are a predetermined number of them
MIPS code must be very carefully put together to efficiently use registers

Assembly Variables: Registers • Registers are numbered from 0 to 31
$0, $1, $2, … $30, $31
• Each register also has a name to make it easier to code: $16-$23 ➔ $s0-$s7
(s correspond to saved temporary variables)
$8 – $15 ➔ $t0 – $t7
(t correspond to temporary variables)
We will come back to s and t when we
talk about “procedure”
In general, use register names to make your code more readable
COMP273 McGill 11

Assembly Variables: Registers
$1, $26, $27 are reserved for assembler and operation system
COMP273 McGill 12

Assembly code is hard to read!
Another way to make your code more readable: comments!
C and Java
/* comment can span many lines */ // comment, to the end of a line
# Anything from hash mark to end of line is a comment and will be ignored
COMP273 McGill 13

Assembly Instructions
C and Java
Each statement could represent multiple operations
Is equivalent to two small operations
a=b+c; a=a–d;
Each statement
(called an Instruction), executes exactly one of a short list of simple commands
COMP273 McGill

Addition and Subtraction

Addition and Subtraction
• Syntax of Instructions:
Operation Destination,Source1,Source2 Operation: by name (Mnemonic)
Destination: operand getting result
Source1: 1st operand for operation
Source2: 2nd operand for operation
• Syntax is rigid:
– Most of them use 1 operator + 3 operands (commas are optional) – Why? Keep Hardware simple via regularity
COMP273 McGill 16

Addition and Subtraction
Try with Mars
// C and Java
add $s0 $s1 $s2
registers $s0,$s1,$s2 are associated with variables a, b, c Subtraction
// C and Java
sub $s3,$s4,$s5
COMP273 McGill
registers $s3,$s4,$s5 are associated with variables d, e, f

Addition and Subtraction
Each Instruction, executes exactly one simple commands
C and Java
a = b + c + d – e;
add $s0, $s1, $s2 #a=b+c
add $s0, $s0, $s3 #a=a+d
sub $s0, $s0, $s4 #a=a-e
COMP273 McGill
Break into
multiple instructions
A single line of C may break up into several lines of MIPS.

• Immediatesarenumericalconstants.
• Specialinstructionsforimmediates:addi
• Syntax is similar to add instruction, except that last argument is a number (decimal or hexadecimal) instead of a register.
// C and Java
f = g + 10 ;
addi $s0 $s1 10 addi $s0 $s1 -10
• There is no subi (use a negative immediate instead)
COMP273 McGill 19

Register Zero
• MIPSdefinesregisterzero($0or$zero)alwaysbe0. • The number zero appears very often in code.
• Use this register, it’s very handy!
add $6$0$5 #copy$5to$6 addi $6 $0 77 # copy 77 to $6
• Register zero cannot be overwritten
COMP273 McGill 20
addi $0 $0 5 # will do nothing

Register Zero • What if you want to negate a number?
sub $6 $0 $5 # $6 = 0 – $5
COMP273 McGill 21

Data Transfer Instructions

Data Transfer Instructions
• MIPSarithmeticinstructionsonlyoperateonregisters • Whataboutlargedatastructureslikearrays?Memory!
– Add two numbers in memory
• Load values from memory into registers • Store result from register to memory
• UseDatatransferinstructionstotransferdatabetween registers and memory. We need to specify
– Register: specify this by number (0 – 31) – Memory address: more difficult
COMP273 McGill 30

Memory Address
Memory is a linear array of byte
Each byte in the memory has its own unique address
We can access the content by supplying the memory address
The processor can read or write the content of the memory
COMP273 McGill

Memory Address
• MemoryAddressSyntax:Offset(AddrReg)
– AddrReg: A register which contains a pointer to a memory location – Offset: A numerical offset in bytes (optional)
# specifies the memory address in $t0 plus 8 bytes
• We might access a location with an offset from a base pointer • The resulting memory address is the sum of these two values
COMP273 McGill 32

Memory Address
4-bit address example
// An array of 8 integers in C/Java
int arr[8]={56,26,88,45,-45,77,98,13} ;
# Assume $s0 has the address 0x1000
0($s0) # 0x1000, to access arr[0] 4($s0) # 0x1004, to access arr[1]
COMP273 McGill

Data Transfer: Memory to Register
• Load Instruction Syntax: lw DstReg, Offset(AddrReg) – lw: Load a Word
– DstReg: register that will receive value
– Offset: numerical offset in bytes
– AddrReg: register containing pointer to memory
lw $t0, 8($s0)
# load one word from memory at
address stored in $s0 with an offset 8 and store the content in $t0
COMP273 McGill 34

Data Transfer: Register to Memory
• Storeinstructionsyntax:swDataReg,Offset(AddrReg) – sw: Store a word
– DstReg: register containing the data
– Offset: numerical offset in bytes
– AddrReg: register containing memory
sw $t0, 4($s0)
# Store one word (32 bits) to memory address $s0 + 4
COMP273 McGill 35

Byte vs. word
• Machines address memory as bytes
• Both lw and sw access one word at a time
• The sum of the base address and
the offset must be a multiple of 4 (to be word aligned)
sw $t0, 0($s0)
sw $t0, 4($s0)
sw $t0, 8($s0)
. .
COMP273 McGill 36

Byte vs. word
Index 8 requires offset of 32 Index 12 reuqires offset of 48
Try with Mars
// C and Java
A[12] = h + A[8] ;
# assume h is stored in $s0 and the base address of A is in $s1 lw $s2 32($s1) # load A[8] to $s2
add $s3 $s0, $s2 # $s3 = $s0 + $s2
sw $s3 48($s1) # store result to A[12]
COMP273 McGill

Register vs. Memory
Operations with registers are faster than memory
Why not keep all variables in memory?
What if more variables than registers?
• MIPS arithmetic instructions can read 2 registers, operate on them, and write 1 per instruction
• MIPS data transfer only read or write 1 operand per instruction, and no operation
• Smaller is faster
COMP273 McGill
• Compiler tries to keep most frequently used variable in registers
• Writing less common to memory: spilling

Pointers vs. Values
• A register can hold any 32-bit value. – a (signed) int,
–anunsigned int,
–a pointer (memory address),
– etc.
lw $t2, 0($t0) # $t0 must contain?
add $t3, $t4, $t5 # what can you say about $t4 and $t5?
COMP273 McGill 39

Review and Information
• The variables in assembly
• Saved Temporary Variables, Temporary Variables, Register Zero
• Addition and Subtraction: add, addi, sub • Data Transfer: lw, sw
• Textbook: 2.1, 2.2, 2.3, A.10 • MARS Tutorial
COMP273 McGill

Leave a Reply

Your email address will not be published. Required fields are marked *