Question

该程序旨在将字符串中的所有小写字母替换为字符 * 。

我遇到的问题是子程序的嵌套调用。即在不同的子例程中使用了一些相同的 $t 和 $a 寄存器。因此，当在另一个子例程中调用一个子例程时，调用者子例程的寄存器就会混乱。

.data
    str: .asciiz "WindOnTheHill" 

.text
    la $a0, str # start of the string
    li $a1, '*'
    jal ReplaceAllLower

    #la $a0, str # start of the string
    jal PrintStr
    jal Exit

ReplaceAllLower:
    # backup return address
    addi $sp, $sp, -12 #  create space for 3 words
               # (3*4=12 bytes) on the stack 
               # (push) for $ra
    sw $ra, 0($sp) # backup return address $ra

    # protect arguments from change
    sw $a0, 4($sp) # backup string address
    sw $a1, 8($sp) # backup char 

    # get string length
    jal StrLen # obtain string length
    move $t0, $v0 # backup string length

    # retrieve argument values  
    lw $a1, 8($sp) # restore char 
    lw $a0, 4($sp) # restore string address

    move $t1, $a0 # obtain string address
    move $t2, $a1 # obtain char
    li $t3, 0 # loop counter    

    while:  
        bgt $t3, $t0, end_while 

        jal IsLower

        beq $t0, 1, lower_case
        j not_lower_case

        lower_case:
            sb $t2, ($a0)           

        not_lower_case: 
            addi $a0, $a0, 1 # increment address
            addi $t3, $t3, 1 # increment loop counter

        j while
    end_while:  

    move $a0, $t1

    # restore stack     
    lw $ra, 0($sp) # restore $ra
    addi $sp, $sp, 16 # return the space on the stack(pop)

    # return 
    jr $ra  

IsLower:
    lb $t0, ($a0) # obtain the character
    li $t1, 97 # 'a' - character
    li $t2, 122 # 'z' - character

    bge $t0, $t1, con1_fulfilled #bigger tha or equal to 0  
    j con1_not_fulfilled

con1_fulfilled:
    ble $t0, $t2, con2_fullfilled #less than or equal to 9
    j con2_not_fulfilled

con2_fullfilled:
    li $v0, 1
    j return

con1_not_fulfilled:
con2_not_fulfilled:
    li $v0, 0

return:                                                                     
    # return 
    jr $ra 

StrLen:
    move $a1, $a0 # start of string
    # run a loop
    li $t0, '\0' # null character 
    li $t1, 0 # prepare the counter

    start_loop: 
        lb $v0, ($a0) # obtain the 1st character

        beq $v0, $t0, end_loop  # exit loop if '\0'-char found

        addi $t1, $t1, 1 # increment counter
        addi $a0, $a0, 1 # increment address

        j start_loop # iterate again
    end_loop:

    move $a0, $a1 #restore string address
    move $v0, $t1 # return value

    # return 
    jr $ra  

PrintStr:   
    li $v0, 4
    syscall
    # return 
    jr $ra


Exit:
    # push $s0 on stack
    addi $sp, $sp, -4 # create 4-bytes on the stack
    sw $s0, ($sp) # cpy $s0 to stack

    #terminate program
    li $v0, 10
    syscall

    # free stack  
        addi $sp, $sp, 4 
    # return 
    jr $ra

_{注意：现在，让我们不要专注于算法。}

所以我的问题是，
我应该使用哪种技术来解决这个问题，因为很难事先知道将来会在哪个子例程中调用哪个子例程（一个库可以随着时间的推移而自我扩展）？

Answer 1

某些约定是必需的，如果所有子例程都遵守它们，则不会有任何问题，例如寄存器被调用过程所破坏。

对于MIPS，普遍接受的呼叫约定是：
*寄存器$t0-7是“临时的”，可以在没有预防措施的情况下使用。如果过程希望在函数调用之间保留其中的一些，则有责任保存它们（“调用者已保存”）。
*寄存器$s0-7（“保存的寄存器”）在没有预防措施的情况下不能使用。如果某个过程要使用其中一些，则必须在使用前保留它们，并在返回时恢复其值（“已保存被调用方”）

调用约定中还有其他重要方面，例如在寄存器$a0-$a3中传递第一个参数，使用$v0-$v1作为返回值等。它们还精确定义了某些寄存器的作用，例如堆栈指针（sp）或帧指针（fp）。 this document是一个很好的摘要，但是您可以在Internet上轻松找到更多详细信息。

保留寄存器是通过call stack完成的。它是一种数据结构，其中包含所有保留的信息。

在函数开始时，必须在堆栈中保留一些空间以存储所有需要保留的信息。然后将要使用的寄存器s0-s7保存在堆栈中。如果该函数是非终端函数（即调用另一个函数），则返回的地址也将被保存。

在调用函数之前，需要保存的临时或自变量寄存器（$t0-7或$a0-3）被写入堆栈。将参数写入寄存器$a0-3或根据需要堆叠。然后调用该函数。

被调用函数返回后，将恢复保留的临时寄存器。

并且函数返回之前，需要恢复保存的$s0-7寄存器和返回地址寄存器（$ra），释放堆栈空间，并调用{{1 }}。

如果所有过程都遵守这些调用约定，则不会有任何问题。编译器遵守这些约定，但是它们依赖于OS和体系结构。

MIPS中具有嵌套调用的子例程

1 个答案: