MIPS汇编语言程序设计

题目：

编写一程序，实现将既包含在数组A中又包含在数组B中的无符号字数取出并存于内存中，其中数组A包含20个数，数组B包含30个数。如找不到相同的数则显示“No same!”

设计流程：

 

 代码：

##############  equal ######################################################################################
# 编写一程序，实现将既包含在数组A中又包含在数组B中的无符号字数取出并存于内存中
# 其中数组A包含20个数，数组B包含30个数。如找不到相同的数则显示“No same!”。
############################################################################################################

#------------代码 segment-------------------#
.text
.globl main



main:
    addi	$s1, $zero, 20			# $s1 = $zero + 20 A的大小
    addi	$s2, $zero, 30			# $s2 = $zero + 30 B的大小
    la		$t0, A		            # 记录A的初始位置
    la		$t1, B		            # 记录B的初始位置
    add		$t2, $0, $0		        # $t1 = $t1 + $t2  用于循环中的计数用 A的计数器
    add		$s0, $0, $0		        # $s0 = $0 + $0     用于双循环
    add     $s4, $0, $0		        # $s4 = $0 + $0     用于记录C的大小
    la		$s3, C		            # 记录C的初始位置(C是目标数组)    
    addi	$s5, $zero, 4

    li		$v0, 4		            # $v0 = 4   输出字符串
    la		$a0, str1		        # 
    syscall
    j		input_A				    # jump to input_A
    

input_A:#输入A并判断是否A内部有元素相等
    addi	$t3, $zero, 4			# $t3 = $zero + 4   
    mult	$t2, $t3			    # $t0 * $t3 = Hi and Lo registers
    mflo	$t3					    # copy Lo to $t3
    add		$t3, $t3, $t0		    # $t3 = $t3 + $t0
    li      $v0, 5                  # 接收键盘输入的整数，并保存到$v0
    syscall                        
    sw      $v0, 0($t3)
    addi	$t2, $t2, 1			    # $t2 = $t2 + 1
    slt     $t4, $t2, $s1           # 如果$t2<$s1，$t4=1，未达上届，否则，$t2=0，已达上届
    bnez    $t4, input_A            # 如果$t4!=0，转loop，继续循环输出，否则，顺序执行，然后结束
    sub	    $t2, $t2, 20		    # $t2 = $t2 - 80  
    li		$v0, 4		            # $v0 = 4
    la		$a0, str2		        # 
    syscall 
    j       input_B
    

input_B:#输入B并判断是否B内部有元素相等
    addi	$t3, $zero, 4			# $t3 = $zero + 4   
    mult	$t2, $t3			    # $t0 * $t3 = Hi and Lo registers
    mflo	$t3					    # copy Lo to $t3
    add		$t3, $t3, $t1		    # $t3 = $t3 + $t0
    li      $v0, 5                  # 接收键盘输入的整数，并保存到$v0
    syscall                        
    sw      $v0, 0($t3)
    addi	$t2, $t2, 1			    # $t2 = $t2 + 1
    slt     $t4, $t2, $s2           # 如果$t2<$s1，$t4=1，未达上届，否则，$t2=0，已达上届
    bnez    $t4, input_B            # 如果$t4!=0，转loop，继续循环输出，否则，顺序执行，然后结束
    sub	    $t2, $t2, 30
    j       judge_same

judge_same:
    add		$s0, $0, $0
    slt     $t6, $t2, $s1           # 如果$t2<$s1，$t6=1，未达上届，否则，$t2=0，已达上届
    bnez    $t6, judge_same_help    # jump to judge_same_help
    j		printf			        # 循环结束
    

judge_same_help:
    mult	$t2, $s5			        # $t0 * $t2 = Hi and Lo registers
    mflo	$t3					    # copy Lo to $t3
    add		$t3, $t3, $t0		    # $t3 = $t3 + $t0
    lw      $t3, 0($t3)             # 用$t3来临时存储A当前的元素

    mult	$s0, $s5			        # $t0 * $t2 = Hi and Lo registers
    mflo	$t4					    # copy Lo to $t4
    add		$t4, $t4, $t1		    # $t4 = $t4 + $t1
    lw      $t4, 0($t4)             # 用$t4来临时存储A当前的元素

    beq		$t3, $t4, equal	        # if $t3 == $t4 then equal
    addi	$s0, $s0, 1			    # $s0 = $s0 + 1
    slt     $t6, $s0, $s2           # 如果$s0<$s1，$t6=1，未达上届，否则，$s0=0，已达上届
    bnez    $t6, judge_same_help            # 如果$t6!=0，转loop，继续循环输出，否则，顺序执行，然后结束

    #判断语句   -----judge_same_help(继续执行循环)
    addi	$t2, $t2, 1             # 否则跳出循环 A计数器自加1
    j		judge_same				# jump to judge_same
    

equal:
    mult	$s4, $s5			        # $t0 * $t2 = Hi and Lo registers
    mflo	$t5					    # copy Lo to $t3
    add		$t5, $t5, $s3		    # $t5 = $t5 + $t0
    sw		$t4, 0($t5)		        # 用$t3来临时存储A当前的元素
    addi	$s4, $s4, 1			    # $s4 = $s4 + 1
    addi	$t2, $t2, 1             # 否则跳出循环 A计数器自加1
    j		judge_same				# jump to judge_same
    

printf:
    slt     $t6, $s4, 1
    bnez    $t6, error
    add		$t3, $zero, 0		    #  t3为新的计数器
    li		$v0, 4		            # $v0 = 4   输出字符串
    la		$a0, str3		        # 
    syscall
    
print_C:  
    mult	$t3, $s5			        # $t0 * $t3 = Hi and Lo registers
    mflo	$t5					    # copy Lo to $t5
    add		$t5, $t5, $s3		    # $t3 = $t3 + $t0
    li      $v0, 1                  # 打印整数，输出一整数
    lw      $t2, 0($t5)
    move    $a0, $t2                # 将输出的数据保存到$a0，为输出做准备
    syscall
    li		$v0, 4		            # $v0 = 4   输出换行符
    la		$a0, msg4		        # 
    syscall
    addi	$t3, $t3, 1			    # $t3 = $t3 + 1
    slt     $t4, $t3, $s4           # 如果$t3<$s1，$t4=1，未达上届，否则，$t3=0，已达上届
    bnez    $t4, print_C            # 如果$t4!=0，转loop，继续循环输出，否则，顺序执行，然后结束
    j		end				        # jump to end
    
error:
    li		$v0, 4		            # $v0 = 4   输出字符串
    la		$a0, str4		        # 
    syscall
    j		end				        # jump to end  

end:
    li		$v0, 4		            # $v0 = 4   输出结束
    la		$a0, end1		        # 
    syscall
    li      $v0, 10                 # 退出，返回系统
    syscall
.data
    A:          .space  80 #预留80个字节 用于保存20个数字
    B:          .space  120 #预留120个字节 用于保存30个数字
    C:          .space  80 #预留80个字节 用于保存相同的数字
    str1:       .asciiz "now please input 20 different unsigned nums for A:\n"
    str2:       .asciiz "now please input 30 different unsigned nums for B:\n"
    str3:       .asciiz "A and B both have:\n"
    str4:       .asciiz "No same!\n"
    msg4:       .asciiz "\n"
    end1:       .asciiz "end\n"