.section startup
.org 0
jmp main


.data
;/****** multiply ******/
multiplicand: .byte 0
multiplier:   .byte 0


;variáveis a ser usadas para 'restaurar' o valor guardado em cada uma delas pois vai ser 'estragado' no decorrimento do programa
multiply_r2:  .word
multiply_r3:  .word
multiply_r4:  .word


;variáveis a ser usadas para 'restaurar' o valor guardado em cada uma delas pois vai ser 'estragado' no decorrimento do programa
mul_array_r0:	.word
mul_array_r1:	.word
mul_array_r4: 	.word
mul_array_r5:   .word


;/********************************************/
price:   .byte 12,15,25,57,200
tax1:    .byte 5,10,23,10,23
amount1: .space 10				;reserva o espaço em unidades de byte, por isso o espaço tem de ser 2x o valor que queremos (5*2)
tax2:    .byte 6,12,24,12
amount2: .space 8               ;reserva o espaço em unidades de byte, por isso o espaço tem de ser 2x o valor que queremos (4*2)



		.text

main:
	ldi  r0,#low(price)
	ldih r0,#high(price)
	ldi  r1,#low(tax1)
	ldih r1,#high(tax1)
	ldi  r2,#low(amount1)
	ldih r2,#high(amount1)
	ldi  r3,#5
	jmpl mul_array

	ldi  r0,#low(tax2)
	ldih r0,#high(tax2)
	ldi  r1,#low(price)
	ldih r1,#high(price)
	ldi  r2,#low(amount2)
	ldih r2,#high(amount2)
	ldi  r3,#4
	jmpl mul_array

	jmp $

;/****************************** multiply **************************************/

;  b) A quantidade de memória de código ocupada pela rotina implementada é dada pelo seguinte cálculo:  0030 - 000C = 0024 ,ou seja 36 bytes.

;  c) Para calcular o número de ciclos máquina gastos na função conta-se todos os ld’s e st’s multiplicando o seu total por 4 (porque tem que ir a memoria) no final e contar todas as outras instruções e multiplicar por 1.
;  Ou seja, (5*4) + (33*1) = 53. O numero de ciclos máquina gastos na função é de 53!


multiply:
;guardar cada valor dos registos nas variáveis correspondentes pois vao ser "estragados"
	st r2, multiply_r2
	st r3, multiply_r3
	st r4, multiply_r4

	ldi  r2,#0            ;result = 0
	ldih r2,#0
	ldi  r3,#0
	ldih r3,#0
	add r3,r3,r0          ;m = multiplicand
	ldi r4,#0; 			  ;i = 0

for_multiply:
	add r1,r1,#0
	jz exit
	shr r6,r1,#1,0		 ;é feito o 'and' com o auxilio de um shift right e guardado em r6 apenas para principios de flag (carry)
	jc  if				 ;caso exista 'carry', ou seja, aconteça o and e portanto !=0 é possível prosseguir para o if

if_end:
	shr r1,r1,#1,0
	shl r3,r3,#1,0
	inc r4
	jmp for_multiply

if:
	add r2,r2,r3            ;result+=m
	jmp if_end
	jmp for_multiply

exit:
	mov r0,r2           	; é movido o conteudo do registo 2 para o registo 0 pois é este que apresenta o retorno das funçoes
	ld r2, multiply_r2  	; antes do 'ret' os registos sao 'restaurados' com os valores anteriormente guardados
	ld r3, multiply_r3
	ld r4, multiply_r4
	ret


;/************************************ mul_array ******************************/

mul_array:
	st  r5, mul_array_r5              ;Guardar o valor do registo 5 porque vai ser estragado nesta funçao, e nao é parametro
	st	r4, mul_array_r4              ;Guardar o valor do registo 4 porque vai ser estragado nesta funçao, e nao é parametro
	ldi r4, #0 	                      ;int i = 0 -> r4



for_mul_array:
	sub r6, r4, r3	                  ; i - size  ->  i<size
	jnc	for_end		                  ;salta para fora do "for" se nao der borrow, ou seja, i=size ou i>size

	; Dentro do for
	st	r0, mul_array_r0              ;guardar o r0 porque vai ser estragado quando for chamado a funçao multiply()
	st	r1, mul_array_r1 			  ; guardar o r1 porque vai ser estragado quando for chamado a funçao multiply()
	ldb r0, [r0,r4]					  ; r0 = a[i]
	ldb	r1, [r1, r4]				  ; r1 = b[i]
	jmpl	multiply
	st	r0, [r2,r4]			          ; c[i] = r0 -> que é o resultado do multiply
	ld	r0, mul_array_r0	          ; repor no r0 o valor que foi guardado de a
	ld	r1, mul_array_r1	          ; repor no r1 o valor que foi guardado de b
	inc r4					          ; i++
	jmp for_mul_array

for_end:
	ld	r4, mul_array_r4	          ; repor o valor original de r4 que foi guardado no inicio da funçao, ou seja, i=0
	ld  r5, mul_array_r5              ; repor o valor original de r5 que foi guardado no inicio da funçao
	ret


.end