Architektury systemów komputerowych - Lista 8.

Załóżcie konta i piszcie co niejasne a nie chodźcie po instytucie i nie mówcie „lol na driki jest źle”, wtf?

• Wykład 8.
• Lista 8
• MIPS Instruction Set
• http://en.wikibooks.org/wiki/MIPS_Assembly

(XY - Z)(X + ZY) = MUL( (XY - Z), (X + ZY)) = MUL(SUB(XY,Z), ADD(X, ZY)) = MUL(SUB(MUL(X,Y),Z), ADD(X, MUL(Z,Y)))

PUSH X
PUSH Y
MUL
PUSH Z
SUB      # SUB(MUL(X,Y),Z)
PUSH Z
PUSH Y
MUL
PUSH X
ADD      # ADD(X, MUL(Z,Y))
MUL
POP W

LOAD X
MUL Y
SUB Z
STORE $A1  # A1 = SUB(MUL(X,Y),Z)
LOAD Z
MUL Y
ADD X
MUL $A1
STORE W

MOVE $A1 X
MUL $A1 Y
SUB $A1 Z  # A1 = SUB(MUL(X,Y),Z)
MOVE $A2 Z
MUL $A2 Y
ADD $A2 X  # A2 = ADD(X, MUL(Z,Y))
MUL $A1 $A2
MOVE W $A1

MUL $A1 X Y
SUB $A1 $A1 Z # $A1 = SUB(MUL(X,Y),Z)
MUL $A2 Z Y
ADD $A2 $A2 X # $A2 = ADD(X, MUL(Z,Y))
MUL W $A1 $A2

Poprawione

W = MIN(X,Y,Z) = MIN(MIN(X,Y),Z)

        PUSH Y
        POP W       ; Tymczasowo W = Y
        PUSH X
        SUB Y
        JMPGTZ yltx ; Jump if MIN(X,Y) = Y
xlty:   PUSH X
        POP W       ; MIN(X,Y) = X
yltx:   PUSH Z
        SUB W
        JMPGTZ end
zltw:   PUSH Z
        POP W
end:

A = A + B

10: SBN T T 20 ; T = 0
20: SBN T B 30 ; T = -B
30: SBN A T 40 ; A = A - -B = A + B

C = A*A
A > 0
X = 1
I - iterator
B - tymczasowa wartość

      SBN B B 10   ; C = 0
10:   SBN I I 20   ; I = 0
20:   SBN Z Z 30   ; Z = 0
30:   SBN Z A 40   ; Z = -A
40:   SBN I Z 50   ; I = 0 - -A = A
50:   SBN I X loop ; I = A - 1 (bo odliczamy do -1, nie 0)
loop: SBN B A 80   ; B -= A
80:   SBN I X end  ; if(I-- < 0) goto end
      SBN P P 90   ; P = 0
90:   SBN P X loop ; goto loop
end:  SBN C C 100  ; C = 0
100:  SBN C B 110  ; C = A*A

Poprawione

$s0 = f
$s1 = g
$s2 = h
$s3 = &A[0]
$s4 = &B[0]

g = -f + h + B[1];
sub $s7, $zero, $s0  ; $s7 = -f
add $s7, $s7, $s2    ; $s7 = -f + h
add $s1, $s7, 1($s4) ; g = $s7 + B[1]

f = A[B[g]+1];
add  $s6, $s1, $s4   ; $s6 = &B[0] + g
lw   $s6, 0($s6)     ; $s6 = B[g]
addi $s6, $s6, 1     ; $s6 = B[g] + 1
add  $s6, $s6, $s3   ; $s6 = &A[0] + B[g] + 1
lw   $s0, 0($s6)     ; f = A[B[g]+1]

http://en.wikipedia.org/wiki/MIPS_architecture#Integer

if f > 1 then
        g = f + f;
        f = 0;
endif;
        g = g + 1;

$s0 = f
$s1 = g
      addi $s3, $zero, 1    ; $s3 = 1
      slt $s2, $s0, $s3     ; $s2 = (f < 1) ? 1 : 0
      bne $s2, $s3, end     ; if(!(f < 1)) goto end;
      add $s1, $zero, $zero ; g = 0
      add $s1, $s0, $s0     ; g = f + f
      add $s0, $zero, $zero ; f = 0
end:  addi $s1, $s1, 1      ; g++

f = 1;
while f < 10 do
        f = f + 1;
endwhile

$s0 = f
      addi $s3, $zero, 1    ; $s3 = 1
      addi $s4, $zero, 10   ; $s4 = 10 ; lol mips
      addi $s0, $zero, 1    ; $s0 = 1
      slt $s2, $s0, $s4     ; $s2 = (f < 10) ? 1 : 0
      bne $s2, $s3, end     ; if(!(f < 10)) goto end
loop:
      addi $s0, $s0, 1      ; f++
      slt $s2, $s0, $s4     ; $s2 = (f < 10) ? 1 : 0
      neq $s2, $s3, loop    ; if(f < 10) goto loop
end:

g = 0;
for f = 1 to 10 do
        g := g + f;

$s0 = f
$s1 = g
      addi $s4, $zero, 11   ; $s4 = 11
      add $s1, $zero, $zero ; g = 0
      addi $s0, $zero, 1    ; f = 1
loop:
      add $s1, $s1, $s0     ; g += f
      addi $s0, $s0, 1      ; f++
      slt $s2, $s0, $s4     ; $s2 = (f < 11) ? 1 : 0
      neq $s2, $s3, loop    ; if(f < 11) goto loop
end:

MIPS Instruction Set
To samo na wiki
Z notatek:

• t0 ­ t7 to rejestry 8 ­ 15
• t8 ­ t9 to rejestry 24 ­ 25
• s0 ­ s7 to rejestry 16 ­ 23

$t0 = 8
$zero = 0
$t1 = 9
$s3 = 19

add $d, $s, $t
000000 sssss ttttt ddddd 00000100000 
add $t0, $t0, $zero
000000 01000 00000 01000 00000100000

lw $t, offset($s)
100011 sssss ttttt iiiiiiii iiiiiiii 
lw $t1, 4($s3)
100011 10011 01001 00000000 00000100

0xAE0BFFFC = 10101110000010111111111111111100
sw $t, offset($s)
101011 sssss ttttt iiiiiiii iiiiiiii 
101011 10000 01011 11111111 11111100
sw $t3, -4($s0)

0x8D08FFC0 = 10001101000010001111111111000000
lw $t, offset($s)
100011 sssss ttttt iiiiiiii iiiiiiii
100011 01000 01000 11111111 11000000
lw $t0, -64($t0)

      addi $t1,    $s0,    400
LOOP: lw   $s1,    0($s0)
      add  $s2,    $s2,    $s1
      lw   $s1,    4($s0)
      add  $s2,    $s2,    $s1
      addi $s0,    $s0,    8
      bne  $t1,    $s0,    LOOP

400/8 = 50 iteracji. 50 * 6 + 1.

      extern int32_t *i;
      extern int32_t result;
      extern int32_t *memarray;
      int32_t dupa;
      i = memarray + 400/sizeof(int32_t);
loop: dupa = memarray[0];
      result += dupa;
      dupa = memarray[4/sizeof(int32_t)];
      result += dupa;
      memarray += 8/sizeof(int32_t);
      if(i != memarray) 
              goto loop;

Czyli:

      extern int32_t result;
      extern int32_t *memarray;
      int i;
      for(i = 0; i < 100; i++)
              result += memarray[i];

Udowodnij równoważność programów:P

Ten kod jest troche lepszy niz naiwne liczenie, poniewaz robi tylko tyle wywolan ile jest jedynek.

    sub $s1, $s1, $s1
for:    
    beq  $s0, $zero, endfor
    subi $t0, $s0, 1
    and  $s0, $s0, $t0
    addi $s1, $s1, 1
    j for
endfor:

gcd:
    addi $t2, $a0, 0
    addi $t3, $a1, 0

    bne  $a0, $zero, while
    addi $v0, $a1, 0
while:
    beq  $a1, $zero, endwhile
    
    slt  $t0, $a1, $a0
    bne  $t0, $zero, blta
altb:
    sub  $a0, $a0, $a1
blta:
    sub  $a1, $a1, $a0
endcase:

    j while
endwhile:
    addi $v0, $a0, 0
lcm:

    div  $t2, $v0
    mflo $t2
    mult $t2, $t3
    mflo $v1