计算机组成原理 第二章 作业

记录计算机组成原理的课后作业

教材为《计算机组成与设计:硬件、软件接口(第4版)》(英文版)

写上一次作业的时候发现国外英文版和国内英文版的课后Exercise数据完全不一样…由于学校要求从此章开始全部采用国内英文版的数据。

Exercise 2.5

  • 2.5.2

    a. MIPS代码:

    1
    2
    3
    4
    5
    6
    7
    8
    lw $t0, 12($s6) # temp = Array[3];
    lw $t1, 0($s6) # Array[3] = Array[0];
    sw $t1, 12($s6)
    lw $t1, 4($s6) # Array[2] = Array[1];
    sw $t1, 8($s6)
    lw $t1, 0($s6) # Array[1] = Array[0];
    sw $t1, 4($s6)
    sw $t0, 0($s6) # Array[0] = temp;

    b. MIPS代码:

    1
    2
    3
    4
    5
    6
    7
    8
    lw $t0, 0($s6)  # temp0 = Array[0];
    lw $t1, 4($s6) # temp1 = Array[1];
    lw $t2, 16($s6) # Array[0] = Array[4];
    sw $t2, 0($s6)
    sw $t0, 16($s6) # Array[4] = temp0;
    lw $t2, 12($s6) # Array[1] = Array[3];
    sw $t2, 4($s6)
    sw $t1, 12($s6) # Array[3] = temp1;

Exercise 2.7

  • 2.7.1

    a.

    按位取反:$0101~0010~1110~1111~1111~1111~1111~1101_{2}$

    加一:$0101~0010~1110~1111~1111~1111~1111~1110 = 1391460350‬_{10} $

    因为首位为1,所以十进制数为-1391460350

    b.

    按位取反:$0000~0000~0000~0000~0100~1100~1010~1100_{2}$

    加一:$0000~0000~0000~0000~0100~1100~1010~1101 = 19629‬_{10}$

    因为首位为1,所以十进制数为-‭19629‬

  • 2.7.2

    a. ‭2903506946‬

    b. ‭4294947667‬

  • 2.7.3

    a. ‭AD100002‬

    b. ‭FFFFB353‬

  • 2.7.4

    a. $2147483647_{10}$

    补码为:‭$0111~1111~1111~1111~1111~1111~1111~1111‬$

    b. $1000_{10}$

    补码为:$‭0011~1110~1000‬$

  • 2.7.5

    a. 十六进制:7FFF FFFF

    b. 十六进制:3E8

  • 2.7.6

    a. ‭8000 0001‬

    b. FFFF FC18

Exercise 2.10

  • 2.10.1

    a. $1010~1110~0000~1011~0000~0000~0000~0100_{2}$

    1
    2
    (Bits: 31 28 26                        5   2 0)
    1010 1110 0000 1011 0000 0000 0000 0100

    当31~29位是101且28~26位是011时,它是sw指令。按照I型指令字段重新排列:

    1
    2
    op      rs      rt		address/immediate
    101011 10000 01011 0000 0000 0000 0100

    因为rs=16 , rt=11immediate=4,根据查找字段值解码得到:

    1
    2
    rs: $s0
    rt: $t3

    所以转换后的汇编指令为:

    1
    sw $t3, 4($s0)

    b. $1000~1101~0000~1000~0000~0000~0100~0000_{2}$

    1
    2
    (Bits: 31 28 26                        5   2 0)
    1000 1101 0000 1000 0000 0000 0100 0000

    当31~29为是100且28~26位是011时,它是lw指令。按照I型指令字段重新排列:

    1
    2
    op	  	rs	 	rt   	address/immediate
    100011 01000 01000 0000 0000 0100 0000

    因为rs=16, rt=16immediate=64,根据查找字段值解码得到rsrt的寄存器都为$t0,所以转换后的汇编指令为:

    1
    lw $t0, 64($t0)
  • 2.10.2

    a和b都为I-type

  • 2.10.3

    a. ‭AE0B0004‬

    b. 8D080040

  • 2.10.4

    a. add \$t0, \$t0, \$zero

    add为R型指令,所以31~26位是000000且5~0位是100000

    因为rdrs$t0即16,所以25~21位是01000且15~11位是01000

    因为rt$zero,所以20~16位是00000

    shamt未使用,所以10~6位是00000

    综上,二进制机器码为000000 01000 00000 01000 00000 100000

    转化为十六进制为$‭1004020‬_{16}$

    b. lw \$t1, 4(\$s3)

    因为oplw ,所以31~26位是100011

    因为rs$t1 即9,所以25~21位是01001

    因为rt$s3 即19,所以20~16位是10011

    因为immediate为4,所以15~0位是0000 0000 0000 0100

    综上,二进制机器码为100011 01001 10011 0000 0000 0000 0100

    转化为十六进制为8D330004‬

  • 2.10.5

    a为R-type,b为I-type

  • 2.10.6

    2.10.4可得

    a.

    1
    2
    3
    4
    5
    op = 0x0;
    rd, rs = 0x8;
    rt = 0x0;
    shamt = 0x0;
    funct = 0x20;

    b.

    1
    2
    3
    4
    op = 0x23;
    rs = 0x9;
    rt = 0x13;
    imm = 0x4;

Exercise 2.11

  • 2.11.1

    a. ‭1010 1110 0000 1011 1111 1111 1111 1100‬

    b. ‭1000 1101 0000 1000 1111 1111 1100 0000‬

  • 2.11.2

    a. ‭2920022012‬

    b. ‭2366177216‬

  • 2.11.3

    a.

    因为op=0xA, 所以为sw, 根据I型指令排列得:

    1
    2
    3
    4
    op = 0b101011;
    rs = 0b10000 = $s0;
    rt = 0b01011 = $t3;
    imm = 0b1111111111111100‬ = -4;

    所以转换后的汇编指令为:

    1
    sw $t3, -4($s0)

    b.

    因为op=0xB, 所以为lw, 根据I型指令排列得:

    1
    2
    3
    4
    op = 0b100011;
    rs = 0b01000 = $t0;
    rd = 0b01000 = $t0;
    imm = 0b1111111111000000‬ = -64;

    所以转换后的汇编指令为:

    1
    lw $t0, -64($t0)
  • 2.11.4

    a为R-type, b为I-type

  • 2.11.5

    a.

    因为op=0funct=32, 所以是add指令

    rs=1=$at, rt=2=$v0, rd=3=$v1shamt=0

    所以汇编指令为:

    1
    add $v1, $at, $v0

    b.

    因为op=0x2B, 所以是sw指令

    rs=0x10=$s0, rt=0x5=$a1, const=0x4

    所以汇编指令为:

    1
    sw $a1, 4($s0)
  • 2.11.6

    a. 000000 00001 00010 00011 00000 100000

    b. 101011 10000 00101 0000 0000 0000 0100

Exercise 2.16

  • 2.16.1

    1
    2
    3
    4
    5
    if($t0 < $t1)
    $t2 = 1;
    else
    $t2 = 0;
    if($t2 == 0) $t2 = 0 + 2;

    a. 因为$t0<$t1, 所以$t2=1

    b. 因为$t0<$t1, 所以$t2=1

  • 2.16.2

    1
    2
    3
    4
    if($t0 < X)
    $t2 = 1;
    else
    $t2 = 0;

    要使\$t2=1,则需要X>\$t0

    a.$t0为1010 1101 0001 0000 0000 0000 0000 0010时,若为无符号数则X为任意立即数,若为有符号数则X在0x‭0002‬到0xFFFF的范围

    b.$t0为1111 1111 1111 1111 1111 1111 1111 1111时,若为有符号数则X在0x8000到0xFFFE的范围

  • 2.16.3

    a. jumpbeq 都不能

    b. jumpbeq 都不能

  • 2.16.4

    1
    2
    3
    4
    5
    6
    if ($t0 < $t0)
    $t2 = 1;
    else
    $t2 = 0;
    if ($t2 != 0)
    $t2 += 2;

    a. $t2 = 2

    b. $t2 = 2

  • 2.16.5

    1
    2
    3
    4
    5
    $t0 = $t0 << 2;
    if ($t0 < 0)
    $t2 = 1;
    else
    $t2 = 0;

    a. $t2 = 0

    b. $t2 = 1

  • 2.16.6

    a. jump能,beq不能

    b. jumpbeq都能

Exercise 2.24

  • 2.24.1

    a. 0x00000012

    b. 0x12FFFFFF

  • 2.24.2

    a. 0x00000080

    b. 0x80000000

  • 2.24.3

    a. 0x00000011

    b. 0x11555555

Exercise 2.25

  • 2.25.1

    a. ‭AD10 0002‬

    1
    2
    lui $t1, 44304  # 44304 dec = 1010 1101 0001 0000 bin
    ori $t1, $t1, 2 # 2 dec = 0000 0000 0000 0010 bin

    b. FFFF FFFF

    1
    2
    lui $t1, 65535
    ori $t1, $t1, 65535
  • 2.25.2

    jump 最大范围到0x0FFFFFFC

    所以a和b都不可以

  • 2.25.3

    2.25.3和2.25.4没懂为什么要-0x20000(2的17次方),网上的答案是这么写的。

    0x604 + 0x1FFFC = 0x0001 0600

    0x604 - 0x20000 = 0xFFFE 0604

    寻址范围是0x0001 0600~0xFFFE 0604

    所以a不可以,b可以

  • 2.25.4

    0x400604 + 0x1FFFC = 0x0042 0600

    0x400604 - 0x20000 = 0x‭003E 0604‬

    所以寻址范围是0x0042 0600 ~ 0x003E 0604

    所以a和b都不可以

  • 2.25.5

    a.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    add  $t1, $zero, $zero  # clear $t1
    addi $t2, $zero, 173 # set top 8 bits 1010 1101
    sll $t2, $t2, 24 # shift left 24 spots
    or $t1, $t1, $t2 # place top 8 bits into $t1
    addi $t2, $zero, 16 # set next 8 bits 0001 0000
    sll $t2, $t2, 16 # shift left 16 spots
    or $t1, $t1, $t2 # place next 8 bits into $t1
    addi $t2, $zero, 0
    sll $t2, $t2, 8
    or $t1, $t1, $t2
    ori $t1, $t1, 2 # or in bottom 8 bits

    b. 和a类似

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    add  $t1, $zero, $zero  # clear $t1
    addi $t2, $zero, 255
    sll $t2, $t2, 24
    or $t1, $t1, $t2
    addi $t2, $zero, 255
    sll $t2, $t2, 16
    or $t1, $t1, $t2
    addi $t2, $zero, 255
    sll $t2, $t2, 8
    or $t1, $t1, $t2
    ori $t1, $t1, 255
  • 2.25.6

    a. 0x1234 5678

    b. 0x1234 0000

  • 2.25.6

    a.

    1
    $t0 = (0x1234 << 16) || 0x5678;

    b.

    1
    2
    $t0 = ($t0 || 0x5678);
    $t0 = (0x1234 << 16);