URS

----------------------------------------------------------------------------------------------
1.
----------------------------------------------------------------------------------------------

.global _start

.text

_start:
    adr r0, pod         /* adresa podatka */
    mov r1, #0xF0000000     /* r1 = 0xF0000000 (kriterij zaustavljanja) */

petlja:
    ldr r2, [r0], #4        /* ucitaj podatak za obradu u r2 */
    cmp r2, r1          /* provjeri kriterij zaustavljanja */
    beq kraj            /* zavrsi ako je kriterij zadovljen */
    cmp r2, #0          /* provjeri je li podatak negativan */
    blt petlja          /* prijedji na sljedci ako je negativan */

    /* rotacija skupina od 4 bita */
    and r4, r2, #0xF0       /* stavi gornja 4 bita zadnjeg bajta u r4 */
    mov r4, r4, LSR #4      /* pomakni 4 bita u desno */
    and r5, r2, #0x0F       /* stavi donja 4 bita zadnjeg bajta u r5 */
    mov r5, r5, LSL #4      /* pomakni 4 bita u lijevo */

    /* rekonstrukcija podatka sa zarotiranim skupinama bitova */
    and r2, r2, #0xFFFFFF00 /* ocisti zadnji bajt podatka */
    orr r2, r2, r4      /* stavi zadnja 4 bita iz r4 u podatak */
    orr r2, r2, r5      /* stavi predzadnja 4 bita iz r5 u podatak*/

    b petlja

kraj:
    b kraj

pod:
.word   0x5a22115a, 0x11223345, -5, 0xF0000000

.end

----------------------------------------------------------------------------------------------
2.
----------------------------------------------------------------------------------------------

.equ len, 0x0100
.global _start

.text

_start:
    adr r0, pod     /* adresa podatka */
    add r1, r0, #len    /* adresa zadnjeg podatka */

    mov r2, #1000       /* pocetni podatak za unos u memoriju */

punjenje_pod:
    add r2, r2, #-50    /* stvori neki novi podatak */
    str r2, [r0], #4    /* spremi podatak iz r2 u memoriju */
    cmp r0, r1      /* provjeri je li se doslo do adrese zadnjeg podatka */
    ble punjenje_pod    /* ako nije, nastavi puniti memoriju podacima */

    adr r0, pod     /* adresa podatka */

    /* pocetak zbrajanja */

    ldr r2, [r0], #4    /* ucitaj donja 32 bita prvog podatka iz memorije u r2 */
    mov r3, #0      /* postavi gornja 32 bita prvog podatka na nulu */

    cmp r2, #0      /* provjeri je li podatak negativan */
    bge zbrajanje       /* ako nije, nastavi zbrajati */
    mvn r3, r3      /* ako jest, invertiraj gornja 32 bita u jedinice */

zbrajanje:

    ldr r4, [r0], #4    /* ucitaj donja 32 bita sljedeceg podatka u r4 */
    mov r5, #0      /* postavi gornja 32 bita na 0 */

    cmp r4, #0      /* provjeri je li podatak negativan */
    bge nastavi_zbroj   /* ako nije, nastavi zbrajati */
    mvn r5, r5      /* ako jest, invertiraj gornja 32 bita u jedinice */

nastavi_zbroj:
    adds r2, r2, r4 /* pribroji donja 32 bita trenutnog broja u r2 */
    adc r3, r3, r5      /* pribroji gornje bitove u r3, uzmi u obzir carry bit */

    cmp r0, r1      /* provjeri kriterij zaustavljanja */
    ble zbrajanje       /* ako nije, nastavi zbrajati */

kraj:
    b kraj

pod:

.end

----------------------------------------------------------------------------------------------
3.
----------------------------------------------------------------------------------------------

.global _start

.text

_start:
    adr r0, pod         /* adresa podatka */
    mov r1, #0xFFFFFFFF     /* podatak koji oznacava kraj */

    mov r2, #0          /* inicijalizacija sume na 0 */

petlja:
    ldrsh r3, [r0], #2      /* ucitaj signed half word podatak u r3 */
    cmp r3, r1          /* provjeri je li se doslo do kraja */
    beq kraj            /* ako jest, izadji iz petlje */

    add r2, r2, r3      /* pribroji podatak iz r3 u r2 */

    b petlja            /* nastavi obradu */

kraj:
    b kraj

pod:
.hword -10, -32000, -29000, 25000, -3, 0xFFFF

.end

----------------------------------------------------------------------------------------------
4.
----------------------------------------------------------------------------------------------

.equ x, 4           /* Prvi broj */
.equ y, 5           /* Drugi broj */
.equ stack_top, 0x1000  /* Vrh stoga na adresi 0x1000 */

.global _start

.text

_start:
    mov sp, #stack_top  /* Spremi vrh stoga u SP */
    mov r0, #x      /* Prvi broj u r0 */
    mov r1, #y      /* Drugi broj u r1 */

    add sp, sp, #-4 /* Rezerviraj mjesto za povratnu vrijednost */
    str r0, [sp], #-4   /* Prvi parametar (x) na stog */
    str r1, [sp], #-4   /* Drugi parametar (y) na stog */

    bl mnozenje     /* Pozovi potprogram */
    ldr r5, [sp, #4]!   /* Ucitaj povratnu vrijednost u r5 */

kraj:
    b kraj

mnozenje:
    ldr r3, [sp, #4]!   /* Dohvat drugog (y) parametra sa stoga */
    ldr r4, [sp, #4]!   /* Dohvat prvog (x) parametra na stoga */
    mul r5, r3, r4  /* Pomnozi i stavi rezultat u r5 */

    str r5, [sp, #4]    /* Stavi rezltat na stog */
    mov pc, lr      /* Vrati se u glavni program */

.end

----------------------------------------------------------------------------------------------
5.
----------------------------------------------------------------------------------------------

.equ blok, 0x1000       /* Adresa bloka je 0x1000 */

.global _start

.text

_start:
    adr r0, pod     /* Adresa podataka */
    mov r1, #blok       /* Stavi adresu bloka u r1 */

punjenje:
    /* Prebacivanje podataka u blok */
    ldr r2, [r0], #4    /* Uzmi podatak u r2 */
    str r2, [r1], #4    /* Spremi podatak iz r2 u blok */
    cmp r2, #0      /* Provjeri jesi li dosao do kraja */
    bne punjenje        /* Ako nisi, nastavi puniti blok */

    mov r0, #blok       /* Stavi adresu pocetka bloka u r0 */
    mov r1, r0      /* Stavi je i u r1 kao pomocni registar */

petlja:
    ldr r2, [r0], #4    /* Uzmi broj iz bloka */
    cmp r2, #0      /* Provjeri je li broj jednak nuli */
    beq kraj        /* Ako jest, zavrsi */
    bgt petlja      /* Ako je veci od 0, preskoci ga */

    /* Zamjena brojeva */
    ldr r3, [r1]        /* Spremi broj s pocetka u r3 */
    str r2, [r1], #4    /* Na njegovo mjesto stavi negativni broj */
    str r3, [r0, #-4]   /* Stavi broj s pocetka na mjesto negativnog broja */

    b petlja        /* Idi na sljedeci broj */

kraj:
    b kraj

pod:

.word -5, 4, 2, -1, -10, 8, 13, 0x00000000

.end

----------------------------------------------------------------------------------------------
6.
----------------------------------------------------------------------------------------------

.global _start

.text

_start:
    adr r0, pod     /* Adresa podataka */
    mov r1, #0      /* Inicijalizacija brojaca elemenata */
    mov r2, #0      /* Inicijalizacija sume elemenata */

zbrajanje:
    ldr r3, [r0], #4    /* Dohvati broj iz memorije */
    cmp r3, #0      /* Provjeri je li broj nula */
    beq dijeljenje  /* Ako jest, zavrsi zbrajanje */

    add r2, r2, r3  /* Dodaj broj u sumu */
    add r1, r1, #1  /* Inkrementiraj brojac */

    b zbrajanje

    mov r3, #0      /* Inicijaliziraj rezultat dijeljenja */
    cmp r1, #0      /* Provjeri dijeli li se s 0 */
    beq kraj        /* Ako dijeli, zavrsi i ostavi rezultat 0 */

/* Dijeljenje oduzimanjem */
dijeljenje:
    cmp r2, #0      /* Provjeri je li dijeljenje zavrseno */
    ble kraj        /* Ako jest, prestani dijeliti */

    sub r2, r2, r1  /* Umanji sumu za ukupan broj elemenata */
    add r3, r3, #1  /* Inkrementiraj rezultat */

    b dijeljenje

kraj:
    b kraj

pod:

.word 8, 3, 4, 0x00000000

.end

----------------------------------------------------------------------------------------------
7.
----------------------------------------------------------------------------------------------

.global _start

.text

_start:
    adr r0, pod     /* Adresa podataka */

petlja:
    ldrb r1, [r0], #1   /* Ucitaj bajt (char) */
    cmp r1, #0      /* Provjeri jesi li dosao do terminatora */
    beq kraj        /* Ako jesi, zavrsi obradu */

    cmp r1, #'A'        /* Provjeri je li slovo manje od velikog slova A */
    blt petlja      /* Ako jest, prijedji na sljedece */
    cmp r1, #'Z'        /* Provjeri je li slovo vece od velikog slova Z */
    bgt petlja      /* Ako jest, prijedji na sljedece */

    add r1, r1, #32 /* Pretvori veliko slovo u malo */
    strb r1, [r0, #-1]  /* Spremi malo slovo u memoriju na mjesto velikog */

    b petlja

kraj:
    b kraj

pod:

.byte 'E', 'r', 'i', 'C', 's', 'S', 'O', 'n', 0x00000000

.end

----------------------------------------------------------------------------------------------
8.
----------------------------------------------------------------------------------------------

.global _start

.text

_start:
    adr r0, pod     /* Adresa podataka */
    mov r1, #0      /* Inicijalizacija brojača */
    mov r2, #0x00000001 /* Maska za ekstrakciju zadnjeg bita */

petlja:
    ldr r3, [r0], #4    /* Ucitaj podatak u r3 */
    cmp r3, #0      /* Provjeri jesi li dosao do kraja */
    beq kraj        /* Ako jesi, zavrsi obradu */

    and r3, r3, r2  /* Pomocu maske ukloni sve bitove osim zadnjeg */
    cmp r3, #0      /* Provjeri je li zadnji bit 0 */
    beq petlja      /* Ako jest, broj je paran, pa prijedji na sljedeci */

    add r1, r1, #1  /* Ako je broj neparan, inkrementiraj brojac */

    b petlja

kraj:
    b kraj

pod:

.word 5, 8, 4, 11, 10, 3, 2, 2, 65, 42, 40, 8, 33, 0

.end

----------------------------------------------------------------------------------------------
9.
----------------------------------------------------------------------------------------------

.equ x, 20
.equ y, 35
.equ blok, 0x1000

.global _start

.text

_start:
    mov r0, #blok       /* Ucitaj adresu bloka */
    mov r1, #x      /* x u r1 */
    mov r2, #y      /* y u r2 */

    str r1, [r0], #4    /* Spremi x u memoriju */
    str r2, [r0], #4    /* Spremi y u memoriju */

    cmp r1, r2      /* Provjeri je li x manji od y */
    blt manji       /* Ako jest oduzmi x - y */
    sub r1, r1, r2  /* Ako nije oduzmi y - x */
    b spremi

manji:
    sub r1, r2, r1

spremi:
    str r1, [r0], #4    /* Spremi rezultat u memoriju */

kraj:
    b kraj

.end