MIPS: utilisation pertinente pour un pointeur de pile ($ sp) et la pile

Actuellement, je suis étudiant pour mon organisation de l'ordinateur à mi-parcours, et j'essaie de comprendre pleinement le pointeur de pile et la pile. Je sais que ces faits suivants qui entourent le concept:

Il suit de la première à la dernière principe
Et d'ajouter quelque chose à la pile prend un processus en deux étapes:
```
addi $sp, $sp, -4
sw $s0, 0($sp)
```

Ce que je pense m'en empêche de pleinement comprendre, c'est que je ne peux pas venir avec une pertinente, l'autonomie apparente de la situation où j'aurais besoin et/ou envie de garder une trace des données avec un pointeur de pile.

Quelqu'un pourrait-il préciser le concept dans son ensemble et de me donner quelques exemples de code?

source d'informationauteur Connor Black

assembly mips

21

Une importante utilisation de la pile est d'imbrication de sous-programme d'appels.

Chaque sous-routine peut avoir un ensemble de variables locales de cette sous-routine. Ces variables peuvent être facilement stockés sur un tapis dans un frame de pile. Certaines conventions d'appel de passer des arguments sur la pile.

À l'aide des sous-routines signifie également que vous devez garder une trace de l'appelant, qui est l'adresse de retour.
Sur certaines architectures, une pile à cette fin, tandis que d'autres utilisent implicitement la "normale" de la pile. MIPS par défaut utilise uniquement un registre, mais dans des feuilles de fonctions (ie. des fonctions qui appellent d'autres fonctions) que l'adresse de retour est écrasé. Par conséquent, vous devez enregistrer la valeur d'origine, généralement sur la pile entre vos variables locales. Les conventions d'appel peut également déclarer que certaines valeurs de registre doit être conservé à travers les appels de fonction, vous pouvez même les enregistrer et de les restaurer à l'aide de la pile.

Supposons que vous avez cette C fragment:
```
extern void foo();
extern int bar();
int baz()
{
    int x = bar();
    foo();
    return x;
}
```
MIPS assemblée peut alors ressembler à ceci:
```
addiu $sp, $sp, -8  # allocate 2 words on the stack
sw $ra, 4($sp)      # save $ra in the upper one
jal bar             # this overwrites $ra
sw $v0, ($sp)       # save returned value (x)
jal foo             # this overwrites $ra and possibly $v0
lw $v0, ($sp)       # reload x so we can return it
lw $ra, 4($sp)      # reload $ra so we can return to caller
addiu $sp, $sp, 8   # restore $sp, freeing the allocated space
jr $ra              # return
```

Le MIPS convention d'appel exige d'abord de quatre paramètres de la fonction pour être dans les registres a0 par a3 et le reste, s'il y a plus, sur la pile. De plus, elle nécessite également la fonction de l'appelant pour allouer de quatre logements sur la pile pour les quatre premiers paramètres, en dépit de ceux passés dans les registres.

Donc, si vous souhaitez accéder au paramètre de cinq (et d'autres paramètres), vous devez utiliser sp. Si la fonction appelle à son tour à d'autres fonctions et utilise ses paramètres après les appels, il sera nécessaire de stocker a0 par a3 dans ces quatre fentes sur la pile pour éviter de les perdre/écrasés. Encore une fois, vous utilisez sp d'écrire ces registres sur la pile.

Si votre fonction a des variables locales et ne peut pas suivre tous d'entre eux dans les registres (comme quand il ne peut pas garder a0 par a3 lors de l'appel à d'autres fonctions), il faudra utiliser l'espace de pile pour ceux variables locales, ce qui nécessite l'utilisation de sp.

Par exemple, si vous avez eu ce:

int tst5(int x1, int x2, int x3, int x4, int x5)
{
  return x1 + x2 + x3 + x4 + x5;
}

son démontage serait quelque chose comme:

tst5:
        lw      $2,16($sp) # r2 = x5; 4 slots are skipped
        addu    $4,$4,$5   # x1 += x2
        addu    $4,$4,$6   # x1 += x3
        addu    $4,$4,$7   # x1 += x4
        j       $31        # return
        addu    $2,$4,$2   # r2 += x1

Voir, sp est utilisé pour accéder à x5.

Et puis si vous avez le code à quelque chose comme ceci:

int binary(int a, int b)
{
  return a + b;
}

void stk(void)
{
  binary(binary(binary(1, 2), binary(3, 4)), binary(binary(5, 6), binary(7, 8)));
}

c'est ce à quoi il ressemble dans le démontage après la compilation:

binary:
        j       $31                     # return
        addu    $2,$4,$5                # r2 = a + b

stk:
        subu    $sp,$sp,32              # allocate space for local vars & 4 slots
        li      $4,0x00000001           # 1
        li      $5,0x00000002           # 2
        sw      $31,24($sp)             # store return address on stack
        sw      $17,20($sp)             # preserve r17 on stack
        jal     binary                  # call binary(1,2)
        sw      $16,16($sp)             # preserve r16 on stack

        li      $4,0x00000003           # 3
        li      $5,0x00000004           # 4
        jal     binary                  # call binary(3,4)
        move    $16,$2                  # r16 = binary(1,2)

        move    $4,$16                  # r4 = binary(1,2)
        jal     binary                  # call binary(binary(1,2), binary(3,4))
        move    $5,$2                   # r5 = binary(3,4)

        li      $4,0x00000005           # 5
        li      $5,0x00000006           # 6
        jal     binary                  # call binary(5,6)
        move    $17,$2                  # r17 = binary(binary(1,2), binary(3,4))

        li      $4,0x00000007           # 7
        li      $5,0x00000008           # 8
        jal     binary                  # call binary(7,8)
        move    $16,$2                  # r16 = binary(5,6)

        move    $4,$16                  # r4 = binary(5,6)
        jal     binary                  # call binary(binary(5,6), binary(7,8))
        move    $5,$2                   # r5 = binary(7,8)

        move    $4,$17                  # r4 = binary(binary(1,2), binary(3,4))
        jal     binary                  # call binary(binary(binary(1,2), binary(3,4)), binary(binary(5,6), binary(7,8)))
        move    $5,$2                   # r5 = binary(binary(5,6), binary(7,8))

        lw      $31,24($sp)             # restore return address from stack
        lw      $17,20($sp)             # restore r17 from stack
        lw      $16,16($sp)             # restore r16 from stack
        addu    $sp,$sp,32              # remove local vars and 4 slots
        j       $31                     # return
        nop

J'espère que j'ai annoté le code sans faire de fautes.

Notez que le compilateur choisit d'utiliser r16 et r17 dans la fonction, mais les conserve sur la pile. Puisque la fonction en appelle une autre, il doit également préserver son adresse de retour sur la pile au lieu de le garder dans r31.

PS Rappelez-vous que l'ensemble de la branche/instructions de saut sur le MIPS exécuter le immédiatement en suivant les instructions avant de transférer le contrôle à un nouvel emplacement. Cela pourrait être source de confusion.

Vous devez vous connecter pour publier un commentaire.