Der MIPS Simulator SPIM

Unterpunkte dieser Seite

    .option pic2
    .set    noreorder

    .data
    .align  4
hellostr:  .ascii  "Hello, World!\n"

    .text
    .align  4
    .globl main

main:
    # create a simple stack frame
    subu      $sp, $sp, 16
    sw        $31, 0($sp)

    # spim print_str syscall
    li        $2, 4
    la        $4, hellostr
    syscall

    # return
    lw        $31, 0($sp)
    addu      $sp, $sp, 16
    j         $31
    nop

# Die ist ein einzeiliger SPIM Kommentar

Aufbau einer Zeile Assemblercode

<label:> <Instruktion> <Arg1> <Arg2> <Arg3> # Kommentar

Bestandteile eines Assemblerprogramms

.data 
  x:  .word 12
  y:  .word 14
  z:  .word 5
  u:  .word 0
.text
main: lw $t0, x           # $t0 := x
      lw $t1, y           # $t1 := x
      lw $t2, z           # $t2 := x
      add $t0$, t0$, t1   # $t0 := x+y
      add $t0, $t0, $t2   # $t0 := x+y+z
      sw $t0, u           # u := x+y+z
      li $v0 10           # EXIT

HINWEIS: Das Fenster, das der WindowManager beim Start von xspim öffnet ist nicht breit genug um die gesammte Ausgabe in den Textbereichen von spim darzustellen. Sie sollten das xspim Fenster auf jeden Fall verbreitern. (Auf dem unteren Screenshot ist das Fenster nicht verbreitert)

[Speicheradresse der Instruktion] (Befehlscode) (Mnemonic des Befehls) ; (Zeilennummer in der Quellcodedatei) (Befehl in der Quellcodedatei)

Single-Stepping

Breakpoints

1. Sehr große Programme mit vielen Anweisungen können Fehler enthalten, die erst nach 1000 Anweisungen auftreten. Single-Stepping (auch in größeren Schrittweiten als eine Anweisung pro Step) ist hier umständlich.
2. Ein Programm kann zwei oder mehr Fehler enthalten (Ja, solche Programme solls geben !). Falls der nach dem ersten Fehler continue gedrückt wird, rauscht das Programm in den zweiten Fehler rein. Man muss also zwischen je zwei Fehlern Single-Stepping machen, was nicht praktikabel ist.

	.data
array0:	.space (array size in bytes)
array1: .space (array size in bytes)

	......
array6: .space (array size in bytes)
	......
	.text

	r = (2*X mod 7);
	switch (r) {
	case 0:
		sw X into array0;
		break;
	case 1:
		sw X into array1;
		break;
	........
	........
	case 6:
		sw X into array6;
		break;
	}

        	.data
        	......
JumpTable: 	.space 28		# why 28?
        	......
        	.text
		......
		......
		la	$10, L0		#loading address of label L0 into $10
					# L0 corresponds to the address of case 0
		sw	$10, JumpTable 	# L0 goes to the first entry of table
		la	$10, L1 	#loading address of label L1 into $10
                                        # L1 corresponds to the address of case
1

		sw	$10, JumpTable+4  # L2 goes to the second entry of table
		.......                 # do so for all seven labels

Der Aktivierungsblock

Allgemeines

StackFrames

Ein Funktionsaufruf

1. Die ersten vier Parameter werden in die Register R4 - R7 (= $a0 - $a3) abgelegt. Falls es weitere Parameter gibt, müssen diese auf den Stack gelegt werden.
2. Die Registerinhalte des Aufrufers müssen gesichert werden, falls diese von interresse sind. Das bedeutet die Register R8 - R15, R24, R25 (= $t0 - $t9) müssen gesichert werden.
3. eine jal Instruction (= unconditionally jump to instruction at target) muss ausgeführt werden.

Innerhalb einer aufgerufenen Funktion

1. establish the stack frame by subtracting the frame size from the stack pointer (Was in aller Welt soll das bedeuten ???)
2. Save the callee-saved registers in the frame. Register $fp is always saved. Register $ra needs to be saved if the routine makes calls. Any of the registers $s0-$s7 that are used by the callee need to be saved.
3. Estbalish the frame pointer by adding the stack frame size -4 to the address in $sp

Aus einer aufgerufenen Funktion returnen

1. Restore any callee-saved registers that were saved upon entry (including the frame pointer &fp)
2. Pop the stack frame by adding the frame size of $sp.
3. Return by jumping to the address in the register &ra

MIPS calling conventions

1. Der Aufrufer schreibt die Parameter in umgekehrter Reihenfolge auf den Stack, so das zuerst der letzte Parameter gepusht wird und zuletzt der erste Parameter gepusht wird. Das bedeutet, der framepointer zeigt auf den letzten Parameter, da der letzte Parameter zuerst gepusht wurde (Parameter in umgekehrter Reihenfolge auf den Stack). Alternativ dazu kann man auch die ersten vier Parameter in die Register $a0 bis $a3 ablegen und falls es mehr als vier Parameter gibt werden diese dann in umgekehrter Reihenfolge auf den Stack gepusht. Der frame pointer zeigt dann auf gar nichts (falls es weniger als fünf Parameter gibt) oder er zeigt auf den letzten Parameter, falls es mehr als vier Parameter gegeben hat.
2. Die caller-saved register ($t0 - $t9) werden auf den Stack gepusht. Dabei wird $t9 zuerst und $t0 zuletzt gepusht.
3. jal aufrufen (jal = unconditionally jump to the instriction at the label or whose address is in the Register Rsrc. Save the address of the next instruction into the Register $31.)