Subversion Repositories marca

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; factorial

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; compute factorials of 1 to 9 and write results to

;;; the PC via UART

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

.data

;;; the numbers to be written are placed here

iobuf:

        data 0x0A

        data 0x0D

        data 0

        data 0

        data 0

        data 0

        data 0

        data 0

;;; stack for recursive calls of factorial()

stack:

.text

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; main()

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

        ldib    r15, 1          ; number to start

        ldib    r5, 10          ; number to stop

        ldil    r1, lo(stack)   ; setup for factorial()

        ldih    r1, hi(stack)

        ldil    r2, lo(factorial)

        ldih    r2, hi(factorial)

        ldib    r6, 0x30        ; setup for convert()

        ldib    r7, 10

        ldil    r8, lo(iobuf)

        ldih    r8, hi(iobuf)

        ldil    r9, lo(convert)

        ldih    r9, hi(convert)

        ldib    r12, -8         ; enable write interrupts

        ldib    r11, (1 << 2)

        store   r11, r12

        ldil    r12, lo(isr)    ; register isr() to be called upon

        ldih    r12, hi(isr)    ; interrupt #3

        stvec   r12, 3

        ldib    r12, -6         ; address where to write data

                                ; to the UART

loop:

        mov     r0, r15         ; r0 is the argument

        call    r2, r3          ; call factorial()

        call    r9, r3          ; call convert()

wait:   getfl   r13

        btest   r13, 4          ; interrupts still enabled?

        brnz    wait

        addi    r15, 1          ; loop

        cmp     r15, r5

        brnz    loop

exit:   br      exit            ; stop here after all

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; converting content of r4 to a string

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

convert:

        addi    r8, 2

convert_loop:

        umod    r4, r7, r10    ; the conversion

        add     r10, r6, r10

        storel  r10, r8

        addi    r8, 1

        udiv    r4, r7, r4     ; next digit

        cmpi    r4, 0

        brnz    convert_loop

        sei                    ; trigger write

        jmp     r3

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; write out content of iobuf

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

isr:

        cmpi    r8, iobuf       ; reached end?

        brz     written

        addi    r8, -1          ; write data to UART

        loadb   r10, r8

        store   r10, r12

        reti

written:

        getshfl r10

        bclr    r10, 4          ; clear interrupt flag

        setshfl r10

        reti

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; recursively compute factorial

;;; argument:           r0

;;; return value:       r4

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

factorial:

        cmpi    r0, 1           ; reached end?

        brule   fact_leaf

        store   r0, r1          ; push argument and return

        addi    r1,  2          ; address onto stack

        store   r3, r1

        addi    r1,  2

        addi    r0, -1          ; call factorial(r0-1)

        call    r2, r3

        addi    r1, -2          ; pop argument and return

        load    r3, r1          ; address from stack

        addi    r1, -2

        load    r0, r1

        mul     r0, r4, r4      ; return r0*factorial(r0-1)

        jmp     r3

fact_leaf:                      ; factorial(1) = 1

        ldib    r4, 1

        jmp     r3