Bài 1:

a,
Số thập phân: 965425896
Số nhị phân (32 bit): 00111001100010110011101011101000
R Format :
Op: 00111
rs : 00110
rt : 00101
rd : 10011
shamt : 10101
funct : 1101000I Format :
Op: 00111
rs : 00110
rt : 00101
offset : 10011101011101000
J Format :
Op: 00111
Address : 001100010110011101011101000

b,
Số thập phân: 965425812
Số nhị phân (32 bit): 00111001100010110011101010010100
R Format :
Op: 00111
rs : 00110
rt : 00101
rd : 10011
shamt : 10101
funct : 0010100I Format :
Op: 00111
rs : 00110
rt : 00101
offset : 10011101010010100
J Format :
Op: 00111
Address : 001100010110011101010010100

c,
Số thập phân: 783712891
Số nhị phân (32 bit): 00101110101101101000001001111011
R Format :
Op: 00101
rs : 11010
rt : 11011
rd : 01000
shamt : 00100
funct : 1111011I Format :
Op: 00101
rs : 11010
rt : 11011
offset : 01000001001111011
J Format :
Op: 00101
Address : 110101101101000001001111011
d,
Số thập phân: 645762921
Số nhị phân (32 bit): 00100110011111011000111101101001
R Format :
Op: 00100
rs : 11001
rt : 11110
rd : 11000
shamt : 11110
funct : 1101001I Format :
Op: 00100
rs : 11001
rt : 11110
offset : 11000111101101001
J Format :
Op: 00100
Address : 110011111011000111101101001
Bài 2: PC=4092, $s1=234, $s2=345, $s3=456.

1,add $s1,$s2,$s3
+,IR = MEMORY[PC]
PC = PC+4 = 4096
A = REG(IR[25-21]) = rs = $s2 = 345
B = REG(IR[20-16]) = rt = $s3 = 456
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A + B = 345+456 = 801
REG (IR[15-11]) = ALU => rd = ALU = $s1 = 801

2,sub $s1,$s2,$s3
+,IR = MEMORY[PC]
PC = PC+4 = 5000
A = REG(IR[25-21]) = rs = $s2 = 345
B = REG(IR[20-16]) = rt = $s3 = 456
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A - B = 345 - 456 = -111
REG (IR[15-11]) = ALU => rd = ALU = $s1 = -111

3,or $s1,$s2,$s3
+,IR = MEMORY[PC]
PC = PC+4 = 5004
A = REG(IR[25-21]) = rs = $s2 = 345 = 0101 0110 01
B = REG(IR[20-16]) = rt = $s3 = 456 = 1110 0010 00
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A or B = 111011001 = 441
REG (IR[15-11]) = ALU => rd = ALU = $s1 = 441

4,and $s1,$s2,$s3
+,IR = MEMORY[PC]
PC = PC+4 = 5008
A = REG(IR[25-21]) = rs = $s2 = 345 = 0101 0110 01
B = REG(IR[20-16]) = rt = $s3 = 456 = 1110 0010 00
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A and B = 010001000 = 136
REG (IR[15-11]) = ALU => rd = ALU = $s1 = 136
5,sw $s1,100($s2)
+,IR = MEMORY[PC]
PC = PC+4 = 5012
A = REG(IR[25-21]) = rs = $s2 = 345 = 0101 0110 01
B = REG(IR[20-16]) = rt = $s3 = 456 = 1110 0010 00
ALU = PC + SE(IR[15-0 ] << 2) = PC + 100*4 = 5412
ALU = A + SE(IR[15-0] ) = A + 100 = 345 + 100 = 435
MEMORY[ALU] = B

6,bne $s1,$s2,-3
+,IR = MEMORY[PC]
PC = PC+4 = 5016
A = REG(IR[25-21]) = rs = $s1 = 234
B = REG(IR[20-16]) = rt = $s2 = 456
ALU = PC + SE(IR[15-0 ] << 2) = PC -3*4 = 5004
PC = ALU = 5004

7,beq $s1,$s2,3
Vì $s1 != $s2 nên PC vẫn không thay đổi, tức là trỏ đến giá trị tiếp theo

8,j 1023
+,IR = MEMORY[PC]
PC = PC+4 = 5008
A = REG(IR[25-21]) = rs = $s1 = 234
B = REG(IR[20-16]) = rt = $s2 = 456
ALU = PC + SE(IR[15-0 ] << 2) = PC + 1023*4 = 9100
PC = PC[31-28] || IR(25-0)<<2

Bài 3:

1,addu $s1,$s2,$s3
+,IR = MEMORY[PC]
PC = PC+4 = 4096
A = REG(IR[25-21]) = rs = $s2 = 345
B = REG(IR[20-16]) = rt = $s3 = 456
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A + B = 345+456 = 801
REG (IR[15-11]) = ALU => rd = ALU = $s1 = 801

2,andi $s1,$s2,100
+,IR = MEMORY[PC]
PC = PC+4 = 5000
A = REG(IR[25-21]) = rs = $s2 = 345 = 0101 0110 01
B = REG(IR[20-16]) = rt = 100 = 1100100
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A and B = 100100 = 36
REG (IR[15-11]) = ALU => rd = ALU = $s1 = 136

3,addiu $s1,$s2,-100
+,IR = MEMORY[PC]
PC = PC+4 = 5004
A = REG(IR[25-21]) = rs = $s2 = 345
B = REG(IR[20-16]) = rt = -100
ALU = PC + SE(IR[15-0 ] << 2)
ALU = A - B = 345 - 100 = 245
REG (IR[15-11]) = ALU => rd = ALU = $s1 =245
5,bne $s1,$s2,12
+,IR = MEMORY[PC]
PC = PC+4 = 5008
A = REG(IR[25-21]) = rs = $s1 = 234
B = REG(IR[20-16]) = rt = $s2 = 456
ALU = PC + SE(IR[15-0 ] << 2) = PC + 12*4 = 5056
PC = ALU = 5056

6,sw $s1,-100($s2)
+,IR = MEMORY[PC]
PC = PC+4 = 5060
A = REG(IR[25-21]) = rs = $s1 = 245
B = REG(IR[20-16]) = rt = $s2 = 345
ALU = PC + SE(IR[15-0 ] << 2) = PC + 100*4 = 5412
ALU = A + SE(IR[15-0] ) = A + 100 = 345 + 100 = 435
MEMORY[ALU] = B