MIPS recuperano indirizzo non allineati su confine di parola, usata .align 4, ancora non va

Question

tutte le idee? Perché sto ottenendo: eccezione di runtime a 0x00400020: prendere indirizzo non allineati su confine di parola linea 0x00000007 problema è: lw $ s1,0 ($ A1) #copy arg2 = dimensione della matrice

.data 
    .align 4 #added this, didnt work 
    size: .word 7 
    .align 4 #added this, didnt work 
    search: .word 30 
    .align 4 #added this,didnt work 
    array: .word 10,20,30,40,50,60,70 
    .align 4 

.text 

main: 

      la $a0,array #$a0 = address of array 
      lw $a1,size #a1 = size of array 
      lw $a2,search #$a2 = search key 


COUNT: 
      lw $s0,0($a0) #copy arg1 = address array 
      addi $s1,$zero,7 
      lw $s1,0($a1) #copy arg2 = size of array 
      lw $s2,0($a2) #copy arg3 = search key (n) 
      addi $s2,$zero,30 
      COUNTLOOP: 
      add $v0,$zero,$zero #v0 = res 
      add $t0,$zero,$zero #$t0 = init i to 0 
      slt $t1,$t0,$s1  #check if i > size of array 
      beq $t1,$zero,DONECOUNT #i is n so end 
      sll $t2,$s0,2  #$t2 = get off set for a[i] 
      lw $t3,0($t2)  #$t3 = get value of a[i] 
      bne $t3,$s2,CLOOPBTM #check if a[i] == seach key 
      addi $v0,$v0,1  #if above then increment res 
      CLOOPBTM: 
      addi $t0,$t0,1 
      j COUNTLOOP 
      DONECOUNT: 

Answer 1

Il problema con il codice è, che non si sta utilizzando l'indirizzo in cui è memorizzato la dimensione ma la dimensione in sé:

Qui si carica l'indirizzo nella A0 e la dimensione (7) in A1:

 la $a0,array 
     lw $a1,size #a1 = size of array 

Qui si carica la prima parola memorizzata nell'array (quello caricherà un 10). Questo non è ciò che intendevi.

 lw $s0,0($a0) #copy arg1 = address array 
     addi $s1,$zero,7 

Qui si carica la prima parola memorizzata nella posizione 0x000007. (la tua taglia). Questo è probabilmente anche non destinati e causerà un'eccezione perché l'indirizzo non è allineato:

 lw $s1,0($a1) #copy arg2 = size of array 

e così via.

Mi sembra, che si dispone di un malinteso che cosa le istruzioni LW fa. Legge una posizione di memoria in un registro. Quello che vuoi nel prologo del tuo ciclo è fare copie di un registro.

Per fare in modo da poter utilizzare l'istruzione pseudo mossa se il vostro assemblatore lo supporta. utilizzare In caso contrario, l'istruzione o per copiare i registri in questo modo:

COUNT: 
      or $s0, $a0, $a0 #copy arg1 = address array 
      addi $s1, $zero,7 
      or $s1, $a1, $a1 #copy arg2 = size of array 
      or $s2, $a2, $a2 #copy arg3 = search key (n) 
      addi $s2, $zero,30 
      COUNTLOOP: 

      ... 

per un esempio completo di un ciclo ricerca lineare provare questo (non testata e si aspetta che l'assembler si preoccupa per gli slot di ritardo)

main: 

      la $a0,array   # $a0 = address of array 
      lw $a1,size    # $a1 = size of array 
      lw $a2,search   # $a2 = search key 


      beq $a1, $zero, NOTFOUND # handle the size==0 case.. 
      or $v0, $zero, $zero # init counter to zero 

LOOP: 
      lw $s0, 0($a0)   # load element 
      beq $s0, $a2, FOUND  # branch if key found: 

      addiu $a0, $a0, 4  # increment array pointer 
      addiu $v0, $v0, 1  # increment loop counter 
      bne $v0, $a1, LOOP  # repeat until we've processed the array. 

NOTFOUND: 
      # -------------------------------------- 
      # if you reach this, key does not exist: 
      # -------------------------------------- 
      li $v0, -1    # load a -1 to signal key not found. 
      jr $lr     # return to caller 

FOUND: 
      # ----------------------------------------- 
      # v0 now contains the position of the key. 
      # ----------------------------------------- 
      jr $lr