CSE 230 part 1

data segment

contains global data for program, .word designated has an initial value and address

arithmetic

convert by integer division, dividing by target base and keep track of remainder, use for decimal to binary and decimal to hex

Von Neumann model

created in the 1940's, common memory system where memory holds data and code/program

parts of MIPS program

data (.data) and code (.text), data starts at 0x10010000 and text starts at 0x00400000

discrete data

data values that have a defined predecessor and successor, ex: integer, char, [floating point not discrete]

assembly language

dependent on hardware (not portable), text representation of machine code

two's complement

one's complement +1, leftmost bit is sign bit, used for negative numbers

pseudo instructions

only core instructions turn to machine code, try not to use

one's complement

opposite of every bit, leftmost bit is sign bit

label

placeholder in a program, value is an address, data segment has assembler directives to specify data and initial values, ex) .data first: .word 5 second: .word 7 str: .asciiz "hello"

high level language

portable, easier to read/write, abstract

Methods for converting bases

positional notation, grouping/expansion, arithmetic

Instruction Set Architecture (ISA)

programmer view of processor, PC, IR, M

memory instructions

read (copy value from memory and store in register) or write (copy from register and store in memory)

the constant zero

$0 is the constant zero, cannot be overwritten

registers

$0 or $zero for all zeroes, $s0, $t0, etc.

syscall memory numbers

(go to memory lecture slides) 4 print a string,5 print an integer

0x2 in binary

0010

0x3 in binary

0011

0x4 in binary

0100

0x5 in binary

0101

0x6 in binary

0110

0x7 in binary

0111

Hex notation

0x comes before

0x8 in binary

1000

0x9 in binary

1001

0xA in binary

1010

0xB in binary

1011

0xC in binary

1100

0xD in binary

1101

word

32 bits/4 bytes (depends on processor but for this class)

byte

8 bits

5 classic components of a computer

CPU control: what to do, CPU datapath: support execution, Memory: primary and secondary, Devices: input and output to communicate to the outside world

Fetch/Execute Cycle

Fetch instruction; .......IR = M[PC]; .......PC = PC + increment; Execute instruction in IR;

Instructions

R-format, <mnemonic> <dest>, <source 1>, <source 2>

nor

a NOR b = NOT (a OR b), NOT operation by NOR with zero, ex) nor $t0, $t1, $0

IR = M[PC]

get instruction address from memory, occurs concurrently with PC increment

base N converted to base M

given an unlimited number of digits, they can be converted without losing any information, BUT when storing data in a computer is not unlimited, data loss could occur

levels of program code

high level language -> compiler -> assembly language -> assembler -> machine code

unconditional branch

j: jump, jal: jump and link (call to function), jr: jump from register (return from function), jumps have to be marked with a label

load upper immediate

lui <reg>, <const>, load half word (2 bytes) into upper half of register, set lower half to 0x0000

load word (reading memory)

lw <reg>, <disp> (<reg>), read word of data from memory, base register holds the address

positional notation

most number systems use this, value depends on digit's position and number's base, use for binary to decimal and hex to decimal

Signed integers can be stored in

signed magnitude, one's complement, two's complement

shift left

sll <dest>, <reg>, <shift>, shift left logical, specify how many bits, 0 to 31 positions, fills on right side with 0, to calculate, convert to bits and then change appropriate bytes

shift right

srl <dest>, <reg>, <shift>, shift right logical, specify bits shift to right, fill on left side with 0, do not sign fill, shift 4 moves over one hex digit, use for dividing by powers of 2

strings

strings end in null terminator, ex: hello takes 6 bytes

save word (writing memory)

sw <reg>, <disp> (<reg>), need base register to hold address, source register with value, write

and

used for mask or isolation of part of register, bitwise

0x1 in binary

0001

0xE in binary

1110

0xF in binary

1111

arithmetic swap

add $s1, $s1, $s2 sub $s2, $s1, $s2 sub $s1, $s1, $s2

Subtract a constant

add a negative value, addi $t0, $t0, -3

or

add bits to a word, bitwise

signed vs unsigned

add vs addu

address v. data

address is location in memory, word address may be divisible by 4

how to access memory

address must be stored in a base register, memory location is calculated by adding base register contents to an offset or displacement, ex) no offset: 0($t0), add 4: 4($t0) [$t0 does not change]

impact on performance

algorithm, programming language, compiler, architecture, processor and memory system

Below your program

applications software above systems software above hardware

machine code

binary

grouping/expansion

binary to hex, hex to binary

logical operations

bitwise manipulation, useful for extracting and inserting groups of bits in a word

labels in code

can mark beginning/ending of loop, functions, target instructions, must be unique in program, do not take up space in assembled program

MIPS instruction set

commercial processor, typical of moderns ISAs, all instructions 32 bits, 32 general registers, some registers for special purposes, 32 bit address

set on less than

compare 2 registers and set a register with result of comparison, 0x00000001 if 1st < 2nd, 0x00000000 if 1st >- 2nd, slt for signed, sltu for unsigned

constants

constant in 2nd source, marked with 'i' for immediate data, values can be decimal or hexadecimal, ex: addi, addiu (16 bits extended to 32 bits)

levels of precedence

evaluate left to right, subtraction and addition same level of precedence

format of MIPS program

every line has only one instruction, #for comments on every instruction

sign extension

extend from 16 to 32 bits, same value

zero extension

extend value zero filled, put zeros in left 4 bytes, value of result may not be the same

printing a string

get address by counting or having assembler do the work, extended instruction la, use in .text, la <reg>, <label name> [loads address of label into register]

program counter (PC)

holds address of next instruction

memory (M)

holds data and code

instruction register (IR)

holds instructions to execute

system calls

not standard MIPS instructions, syscall used for calls to the operating system (input/output), load $v0 with command to execute, put output value in $a0 (or $f12), get input result from $v0 (or $f0)

signed magnitude

one bit is for the sign, leftmost bit

Range of values in N bits

unsigned: 0...(2^N) -1, 1's complement: -((2^N-1)-1)...((2^N-1)-1), 2's complement: -(2^N-1)...((2^N-1)-1); 2's has one more value because 1's has + and - 0