====== 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?**__
  * {{:ask:09.skrypt08.pdf|Wykład 8}}.
  * {{:ask:09.lista08.pdf|Lista 8}}
  * [[http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html|MIPS Instruction Set]]
  * [[http://en.wikibooks.org/wiki/MIPS_Assembly]]

===== Zadanie 1. =====
(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)))
=== a) ===
  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
=== b) ===
  LOAD X
  MUL Y
  SUB Z
  STORE $A1  # A1 = SUB(MUL(X,Y),Z)
  LOAD Z
  MUL Y
  ADD X
  MUL $A1
  STORE W
=== c) ===
  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
=== d) ===
  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

===== Zadanie 2. =====
**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:

===== Zadanie 3. =====
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

===== Zadanie 4. =====
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

===== Zadanie 5. =====
**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]

===== Zadanie 6. =====
http://en.wikipedia.org/wiki/MIPS_architecture#Integer
=== a) ===

  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++

=== b) ===

  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:
=== c) ===

  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:

===== Zadanie 7. =====
[[http://www.mrc.uidaho.edu/mrc/people/jff/digital/MIPSir.html|MIPS Instruction Set]]\\
[[http://en.wikipedia.org/wiki/MIPS_architecture#Integer|To samo na wiki]]\\
Z notatek:
  * t0 ­ t7 to rejestry 8 ­ 15
  * t8 ­ t9 to rejestry 24 ­ 25
  * s0 ­ s7 to rejestry 16 ­ 23
=== a) ===
  $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

=== b) ===
  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)

===== Zadanie 8. =====
=== kod MIPS ===
        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
=== ilość operacji ===
400/8 = 50 iteracji. 50 * 6 + 1.
=== kod C ===
        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

===== Zadanie 9. =====

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:

===== Zadanie 10. =====
  
  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 


{{tag>[listy_zadan]}}