Jump-Anweisung in MIPS Assembly

Hier einige MIPS-Assembler-code schrieb ich zum testen der Sprung-Anweisung:

addi $a0, $0, 1
j next
next:
j skip1
add $a0, $a0, $a0
skip1:
j skip2:
add $a0, $a0, $a0
add $a0, $a0, $a0
skip2:
j skip3
loop:
add $a0, $a0, $a0
add $a0, $a0, $a0
add $a0, $a0, $a0
skip3:
j loop

Wenn ich den assembler, hier ist das Ergebnis:

[0x000000]  0x20040001  # addi $a0, $zero, 1 ($a0 = 1)
[0x000004]  0x08000002  # j 0x0002 (jump to addr 0x0008)
[0x000008]  0x08000004  # j 0x0004 (jump to addr 0x0010)
[0x00000C]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x000010]  0x08000007  # j 0x0007 (jump to addr 0x001C)
[0x000014]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x000018]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x00001C]  0x0800000B  # j 0x000B (jump to addr 0x002C)
[0x000020]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x000024]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x000028]  0x00842020  # add $a0, $a0, $a0 ($a0 = $a0 + $a0)
[0x00002C]  0x08000008  # j 0x0008 (jump to addr 0x0020)

Blick auf den Maschinen-code für die jump-Anweisungen, das ist, was ich sehe:

1st jump (just jumps to next instruction) 0x08000002
2nd jump (skips 1 instruction) 0x08000004
3rd jump (skips 2 instructions) 0x08000007
4th jump (skips 3 instructions) 0x0800000B
5th jump (skips 3 instructions backwards) 0x08000008

Blick auf diese Anleitung, es sieht aus wie der Maschinen-code beginnt mit einem 08 für die jump-Anweisung, und die Zahl am Ende sagt die jump-Anweisung, wohin Sie gehen. Aber ich kann nicht herausfinden, wie diese Zahl berechnet wird. Auch, es ist nichts zu zeigen mir, dass der 5. Sprung rückwärts springen.

Wie ist den Sprung Wert berechnet?

  • warum verwenden Sie 3 add $a0, $a0, $a0? warum nicht verwenden sll $a0, $a0, 3
  • lassen Sie mich daran erinnern, dass Sie verdienen es, ein cookie für diese
InformationsquelleAutor node ninja | 2011-10-24
  1. 15

    Schauen Sie in ein Referenz-Handbuch für weitere details über die opcode Codierung.

    Kurze version: In einem 32-bit-Anweisung können Sie keine 32-bit-Ziel springen. Der opcode verwendet 6 bits, die Blätter 26 bit für den Befehl. Die Ziel-Adresse wird konstruiert indem man die ersten 4 bits der Adresse der Instruktion nach der j Unterricht, dann 2 null-bits angehängt, den 26 bit aus dem jump-Anweisung Operanden. (Wie in der Anleitung von 32 bits, die Ausrichtung ist nützlich und ermöglicht das weglassen der letzten beiden 0 ist.)

    Backward jump: Die Adressen werden absolut und NICHT relativ, so hängt es nur von der Adresse des sprungbefehls, ob es ein vorwärts-oder rückwärts springen.

    BEARBEITEN: genauere Beschreibung:
    Wir haben unter der Adresse x jump-Anweisung j. Lassen Sie t stellen die Sprung-operand j. t ist 26 bit breit.
    Die bit-Muster der Adresse der nächsten Anweisung wird wie folgt berechnet:

    upper_6_bits_of(x+4),t,0,0

    Also der Sprung ist IMMER absolute. Es gibt keine relativen Sprünge. wenn das Ergebnis kleiner ist als x, dann ist es eine rückwärts springen, wenn es größer ist, es ist ein vorwärts springen (und wenn Sie wollen, etwas dumm, machen Sie es gleich ;-).

    Also schauen wir uns auf dem 5. Sprung von deinem Beispiel:

    Den ersten 6 bits des Sprung-Ziel: 000000, weil die oberen 6 bits von der Adresse der Anweisung, die hinter dem Sprung ist 000000.

    Den nächsten 26 bits der niedrigsten 26 bits der Anweisung springen, das ist 00000000000000000000001000

    Die letzten 2 bits: 00, denn der bekam immer angehängt.

    Haben wir gemeinsam: 0000000000000000000000000000100000, die hex-20. Und an dieser Adresse ist genau die Beschriftung/Anleitung, wo die Strömung sollte fortgesetzt werden.

    • Dies beantwortet nicht die Frage, wie sich die relative Adresse ist die Angabe eines nach hinten versetzt. In der Regel, die jmp relativen Wert wäre negativ, dies zu erreichen. Auch offsets oben nicht viel Sinn für Sprünge. Ich habe, wie @z-buffer, bin auch ein bisschen verwirrt durch die Demontage...
    • Dein edit erklärt den Sprung als absolute, aber die offsets noch nicht wirklich line-up. Es muss um etwas anderes geht. +1 noch für die Beantwortung der vollständige Frage.
    • Dorgan: Der Rückwärts springt ist es in Ordnung, wie es ist: Es zeigt, wie ...08. Dass 08 Links verschoben durch zwei (die beiden 2 Nullen, die ich erwähnt) sind 32 (mit dem hex 0x20. Und die Anweisung, wo die Sprünge geht, ist 0x..20. So passt es perfekt (gleiche mit den anderen 4 Sprünge).
    • Alles Verstand ich aus Ihrer Antwort war, dass zwei bits Hinzugefügt am Ende. Könnten Sie erklären, in einer mathematischen Art und Weise und zeigen, wie es funktioniert in diesem Fall? Auch ist es nicht klar, aus Ihrer Erklärung, ob die vorwärts-Sprung-Adressen sind relative oder nicht.
    • Ach Herrje, ich war das zählen labels wie op-codes, wenn ich nicht meine Anweisung zu zählen. Perfekt macht nun Sinn. Danke.
    • Verständnis zu erleichtern, wird der Wert in der jump-Anweisung ist die Anzahl der Anweisungen von Anfang an in die ausführbare Datei (Basis 0). Der erste Sprung hat ...02, so geht es nach der 3. op-code. Die nächste endet in 4 so geht es nach der 5. op-code, und so weiter für jeden Sprung. Der Teil über die hohen bits nur von Bedeutung, wenn sehr, sehr weite Sprünge und, wenn die Daten die Schritte über Speicher-Grenzen - etwas, das Sie nicht brauchen, um über Sie für eine Weile.
    • Also in anderen Worten, die Anzahl der in der Sprungbefehl einfach den hex-Wert der Ziel-Adresse in Binär nach rechts verschoben um 2 bits.
    • ja (außer die 6 obersten bits).
    • Warum sind die Ober - 6 bits genommen? Sollte es nicht das Obere 4 bits? Denn aus meinem Verständnis, die oberen 6 bits + 26 bits vom Unterricht + 2 bits Verschiebung macht 34, 32.

    InformationsquelleAutor flolo
  2. 6

    In MIPS J ist ein J-Typ-Anleitung:

    J-type instructions (Jumps)
3    22
1    65                        0
+----+-------------------------+
| op |         target          |
+----+-------------------------+

    So haben wir eine target ist 26 bit lang. Es wird in Kombination mit der PC der next-Anweisung, wie folgt:

    I
I+1 PC <- (PC & 0xf0000000) | (target << 2)

    Es ist 2 bits nach Links verschoben, da MIPS Instruktionen (ignoriert die MIPS16-Erweiterung) sind 32-bit lang, das heißt, Sie beginnen alle in einer Adresse, deren untere 2 bits sind null.

    • Ein anderer Weg, um daran zu denken ist, was ist der kleinste Wert ungleich null, können Sie in eine jump-Anweisung? Das wäre eine 1, und es entspricht der 2. Anweisung im Programm, die auf 0x4. Also im Grunde ist es ein Sprung an die absolute Adresse der Anweisung, geteilt durch 4, da die Adressen sind N-te Anweisung ist immer (n-1)*4. Division durch 4, eine Verschiebung nach rechts um 2 bits, da die Verlagerung rechten n bits teilt die Zahl (2^n).
    InformationsquelleAutor ninjalj
Schreibe einen Kommentar