API tools faq
paste
Advertisement
Guest User

MIPSReadme

a guest
Dec 11th, 2018
122
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.78 KB | None | 0 0
raw download clone embed print report
  1. ####String Concat Input
  2.  
  3. .data
  4.  
  5. msg1: .asciiz "Enter String 1 : "
  6. msg2: .asciiz "Enter String 2 : "
  7. msg3: .asciiz "Concatenated String (1) : "
  8.  
  9. str1: .space 20
  10. str2: .space 20
  11.  
  12. newline: .asciiz "\n"
  13.  
  14. .text
  15. .globl main
  16.  
  17. main:
  18.  
  19. li $v0, 4 # print msg1
  20. la $a0, msg1
  21. syscall
  22.  
  23. li $v0, 8 # input str1
  24. la $a0, str1
  25. li $a1, 20 # max length = 20
  26. syscall
  27.  
  28. move $a2, $a0 # $a2 = *str1 = *dst
  29.  
  30. li $v0, 4 # print msg2
  31. la $a0, msg2
  32. syscall
  33.  
  34. li $v0, 8 # input str2
  35. la $a0, str2
  36. li $a1, 20 # max length = 20
  37. syscall
  38.  
  39. move $a3, $a0 # $a3 = *str2 = *src
  40.  
  41. # arguments : *str1 in $a2 and *str2 in $a3
  42.  
  43. jal strcat # call strcat()
  44.  
  45. # return address in $v1 even though it doesn't matter since $v1 = $a2 ie. address of str1/dst
  46.  
  47. li $v0, 4 # print msg3
  48. la $a0, msg3
  49. syscall
  50.  
  51. li $v0, 4 # print result
  52. la $a0, 0($a2)
  53. syscall
  54.  
  55. li $v0, 10 # exit
  56. syscall
  57.  
  58. strcat:
  59. li $t0, 0 # $t0 = i = 0
  60. li $t3, 0 # $t3 = j = 0
  61.  
  62. loop1:
  63. add $t1, $t0, $a2 # $t1 = addr of str1[i]
  64. lbu $t2, 0($t1) # $t2 = str1[i]
  65.  
  66. beq $t2, $zero, remove_newline # if *str1 == 0 { goto remove_newline }
  67.  
  68. addi $t0, $t0, 1 # i++
  69. j loop1
  70.  
  71. remove_newline:
  72. addi $t1, $t1, -1 # remove newline from the end of dst/str1 coz it counts as a character (lol)
  73.  
  74. loop2:
  75. add $t4, $t3, $a3 # $t4 = addr of str2[i]
  76. lbu $t5, 0($t4) # $t5 = str2[i]
  77.  
  78. beq $t5, $zero, end_loop # if *str2 == 0 { goto end_loop }
  79.  
  80. sb $t5, 0($t1) # str1[i] = str2[j]
  81.  
  82. addi $t1, $t1, 1 # dst++
  83. addi $t3, $t3, 1 # src++
  84. j loop2
  85.  
  86. end_loop:
  87. lb $t6, 0($t4) # *dst = *src = '/0'
  88. sb $t6, 0($t1)
  89.  
  90. move $v1, $a2
  91. jr $ra # return to caller
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98. ####Sort
  99. for (i = ..)
  100. for (j...)
  101. if (option == 0) for every element this is done
  102. if a[i] > a[j] ascending
  103. swap
  104. else
  105. if a[i] < a[j] descening..
  106.  
  107. main:
  108. la $t0, L1
  109. lw $t1, 0($t0)
  110. #modify $t1 with opcode of blt
  111. sw $t1, 0($t0)
  112.  
  113. jal sort
  114.  
  115.  
  116. sort:
  117. li $t0, 0
  118. add $t1, $t0, 1
  119.  
  120.  
  121. L1 : bgt ....
  122.  
  123. jr $r31
  124.  
  125.  
  126.  
  127.  
  128.  
  129. #####GCD nonrecursive
  130. .data
  131.  
  132. msg1: .asciiz "Enter number 1: "
  133. msg2: .asciiz "Enter number 2: "
  134. msg3: .asciiz "GCD : "
  135.  
  136. num1: .word 0
  137. num2: .word 0
  138. res: .word 0
  139.  
  140. newline: .asciiz "\n"
  141.  
  142. .text
  143. .globl main
  144.  
  145. main:
  146.  
  147. li $v0, 4 # print msg1
  148. la $a0, msg1
  149. syscall
  150.  
  151. li $v0, 5
  152. syscall # getting input num1
  153. sw $v0, num1
  154.  
  155. li $v0, 4 # print msg2
  156. la $a0, msg2
  157. syscall
  158.  
  159. li $v0, 5
  160. syscall # getting input num2
  161. sw $v0, num2
  162.  
  163. lw $t1, num1
  164. lw $t2, num2
  165. li $t0, 1 # i = 1
  166. li $t3, 0 # gcd = 0
  167.  
  168. loop:
  169. bgt $t0, $t1, end_loop
  170. bgt $t0, $t2, end_loop
  171.  
  172. divu $t1, $t0
  173. mfhi $t4 # t4 = num1%i
  174. bne $t4, 0, try_next_i
  175.  
  176. divu $t2, $t0
  177. mfhi $t4 # t4 = num2%i
  178. bne $t4, 0, try_next_i
  179.  
  180. move $t5, $t0 # if(n1%i==0 && n2%i==0) {gcd = $t5 = i;}
  181.  
  182.  
  183. try_next_i:
  184. addiu $t0, $t0, 1 # i++
  185. j loop
  186.  
  187. end_loop:
  188. sw $t5, res # store result
  189.  
  190. li $v0, 4 # print msg3
  191. la $a0, msg3
  192. syscall
  193.  
  194. li $v0, 1
  195. lw $a0, res # output gcd
  196. syscall
  197.  
  198. li $v0, 10 # exit
  199. syscall
  200.  
  201.  
  202.  
  203. ####GCD recursive
  204. .data
  205. num1: .word 0
  206. num2: .word 0
  207. result: .word 0
  208. buffer: .asciiz ""
  209. msg1: .asciiz "A : "
  210. msg2: .asciiz "B : "
  211. msg3: .asciiz "GCD : "
  212.  
  213. .text
  214. .globl main
  215. main:
  216. # Print msg1
  217. li $v0, 4
  218. la $a0, msg1
  219. syscall
  220.  
  221. # Input num1
  222. li $v0, 5
  223. syscall
  224. sw $v0, num1
  225.  
  226. # Print msg2
  227. li $v0, 4
  228. la $a0, msg2
  229. syscall
  230.  
  231. # Input num2
  232. li $v0, 5
  233. syscall
  234. sw $v0, num2
  235.  
  236. # Set arguments
  237. lw $a0, num1
  238. lw $a1, num2
  239.  
  240. # Call gcd
  241. jal gcd
  242. sw $v0, result
  243.  
  244. # Print msg3
  245. li $v0, 4
  246. la $a0, msg3
  247. syscall
  248.  
  249. # Print result
  250. li $v0, 1
  251. lw $a0, result
  252. syscall
  253.  
  254. # Terminate
  255. li $v0, 10
  256. syscall
  257. .end main
  258.  
  259.  
  260. .globl gcd
  261. .ent gcd
  262. gcd:
  263. addi $sp, $sp, -12
  264. sw $ra, ($sp)
  265. sw $a0, 4($sp)
  266. sw $a1, 8($sp)
  267.  
  268. div $a0, $a1
  269. mfhi $v0
  270.  
  271. beq $v0, $zero, gcddone
  272.  
  273. add $a0, $a1, $zero
  274. add $a1, $v0, $zero
  275. jal gcd
  276.  
  277. gcddone:
  278. add $v0, $a1, $zero
  279. lw $ra, ($sp)
  280. lw $a0, 4($sp)
  281. lw $a1, 8($sp)
  282. addi $sp, $sp, 12
  283. jr $ra
  284. .end gcd
  285.  
  286.  
  287.  
  288.  
  289. ####Exponential Recursive
  290. #int power (int a, int n)
  291. #{
  292. # if (n == 1) return a;
  293. # return a * power(n - 1);
  294. #}
  295. #main()
  296. #{
  297. # pow = power(a, n);
  298. #}
  299.  
  300.  
  301. .data
  302. a: .word 9
  303. n: .word 5
  304. pow: .word 0
  305.  
  306.  
  307. .text
  308. .globl main
  309. main:
  310. lw $a0, a
  311. lw $a1, n
  312. jal power
  313. sw $v0, pow
  314.  
  315. li $v0, 1
  316. lw $a0, pow
  317. syscall
  318.  
  319. li $v0, 10
  320. syscall
  321.  
  322. power:
  323. addi $sp, $sp, -8 # adjust stack for 2 items
  324. sw $ra, 4($sp) # save return address
  325. sw $a0, 0($sp)
  326. addi $t1, $zero, 1 # $t1 = 1
  327. bgt $a1, $t1, L1 # if $a1(=n) > $t1(=1) goto L1
  328. move $v0, $a0 # if $a1(=n) == $t1(=1), result is $a0(=n)
  329. addi $sp, $sp, 8 # pop 2 items from stack
  330. jr $ra # and return
  331. L1:
  332. addi $a1, $a1, -1 # decrement n
  333. jal power # recursive call: $v0=power(a, n-1)
  334. lw $a0, 0($sp) # restore original a
  335. mul $v0, $a0, $v0 # pseudo inst: multiply $v0=$a0(=a)*$v0(=power(a,n-1))
  336.  
  337. lw $ra, 4($sp) # retrive return address
  338. addi $sp, $sp, 8 # restore sp
  339. jr $ra # and return
  340.  
  341.  
  342.  
  343. #####Binary Search
  344. # isFound = 0
  345. # lo = 0
  346. # high = n-1
  347. # while (lo <= high) {
  348. # mid = (lo + high)/2;
  349. # if (data == A[mid]) { isFound = 1; break; }
  350. # if (data < A[mid]) { high = mid - 1; continue;}
  351. # low = mid + 1;
  352. #}
  353.  
  354. .data
  355. A: .word -32, -16, 0, 8, 16, 32, 64
  356. n: .word 7
  357. data: .word -16
  358. msg1: .asciiz " Found at pos: "
  359. msg2: .asciiz " Not found"
  360.  
  361. .text
  362. .globl main
  363. main:
  364. lw $t0, data # $t0 = (data)
  365. li $t1, 0 # $t1 = 0 (isFound)
  366. li $t2, 0 # $t2 = 0 (lo)
  367. lw $t3, n # $t3 = n
  368. add $t3, $t3, -1 # $t3 = n-1 (high)
  369. L1:
  370. bgt $t2, $t3, end_loop # if (lo > hi) end_loop
  371. add $t4, $t2, $t3 # $t4 = lo + high
  372. srl $t4, $t4, 1 # shift right logical: $t4 = $t4/2 (mid)
  373. sll $t5, $t4, 2 # shift left logical: $t5 = $t4 * 4
  374. lw $t6, A($t5) # $t6 = A[mid]
  375. bne $t0, $t6, not_equal # $t0 != $t6 (data != A[mid])
  376. li $t1, 1 # $t1 = 1 (isFound = 1)
  377. j end_loop # jmp outside loop
  378. not_equal:
  379. blt $t0, $t6, less_than # $t0 < $t6 (data < A[mid])
  380. addiu $t2, $t4, 1 # ($t2)lo = ($t4)mid + 1
  381. j L1 # continue from begining.
  382. less_than:
  383. addiu $t3, $t4, -1 # ($t3)high = ($t4)mid - 1
  384. j L1 # continue from begining.
  385.  
  386. end_loop:
  387. li $v0, 1 # print int
  388. move $a0, $t0 # $a0 = data
  389.  
  390. syscall
  391. li $v0, 4
  392. beq $t1, $zero, msg_nf # if (isFound == 0)
  393.  
  394. la $a0, msg1 # isFound == 1 display msg
  395. syscall
  396.  
  397. li $v0, 1 #
  398. move $a0, $t4 # $a0 = mid
  399. syscall
  400. j exit
  401. msg_nf :
  402. la $a0, msg2 # isFound == 0 display msg
  403. syscall
  404. exit:
  405. li $v0, 10 # exit
  406. syscall #
  407.  
  408.  
  409.  
  410.  
  411.  
  412. #####Sum of array elements
  413. .data
  414. arr: .word 10, 20, 30, 40
  415. num: .word 4
  416. msg: .asciiz "The sum of nos = "
  417. sum: .word 0
  418.  
  419. .text
  420. .globl main
  421. main:
  422. li $t0, -1
  423. li $t0, 0 # $t0=sum=0
  424. li $t1, 0 # $t1=i=0
  425. lw $t2, num # $t2=num
  426. next_i:
  427. bge $t1, $t2, end_loop # if i>=num goto over
  428. sll $t3, $t1, 2 # $t3 = $t2 (i) << 2
  429. lw $t4, arr($t3) #$t4 = Arr(i)
  430. add $t0, $t0, $t4 # sum = sum + arr(i)
  431. addu $t1, $t1, 1 # i = i +i
  432. j next_i
  433. end_loop:
  434. sw $t0, sum # sum=$t0
  435.  
  436. li $v0, 4
  437. la $a0, msg
  438. syscall
  439.  
  440. li $v0, 1 #
  441. lw $a0, sum
  442. syscall
  443.  
  444.  
  445.  
  446. li $v0, 10 # exit
  447. syscall #
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454. #####Check pirme
  455. .data
  456. msg1: .asciiz "Enter the no: "
  457. msg_is_prime:
  458. .asciiz "The no is prime\n"
  459. msg_is_not_prime:
  460. .asciiz "The no is not prime\n"
  461. num: .word 0
  462.  
  463. newline : .asciiz "\n"
  464. .text
  465. .globl main
  466.  
  467. main:
  468. li $v0, 4 # syscall 4 (print_str)
  469. la $a0, msg1 # argument: string
  470. syscall # print the string
  471.  
  472. li $v0, 5
  473. syscall
  474. sw $v0, num
  475.  
  476. lw $t0, num # $t0 = num
  477. srl $t1, $t0, 1 # $t1 = num/2
  478. li $t2, 1 # $t2 = isPrime = 1
  479. li $t3, 2 # $t3 = i = 2
  480. next_i:
  481. bleu $t3, $t1, calc_rem # if (i < num/2) then calc_rem
  482. j check_is_prime
  483. calc_rem:
  484. divu $t0, $t3 # num % i
  485. mfhi $t4 # $t4 = rem (hi)
  486. bne $t4, $0, try_next_i # if (rem != 0) try_next_i
  487. li $t2, 0 # if (rem == 0) isPrime = 0; break
  488. j check_is_prime #
  489. try_next_i:
  490. addiu $t3, $t3, 1 # i = i + 1
  491. j next_i # goto next_i
  492.  
  493. check_is_prime:
  494. beq $t2, $0, is_not_prime # isPrime == 0
  495. la $a0, msg_is_prime
  496. j print_msg
  497. is_not_prime:
  498. la $a0, msg_is_not_prime
  499.  
  500. print_msg:
  501. li $v0, 4
  502. syscall
  503.  
  504. li $v0, 10 # exit
  505. syscall #
  506.  
  507.  
  508.  
  509.  
  510. ####Sum to N numbers
  511. #
  512. # int i, sum = 0;
  513. # for (i=0; i < N; i++)
  514. # sum = sum + i
  515. #
  516.  
  517. .data
  518. msg1: .asciiz "Enter N: "
  519. msg2: .asciiz "The Sum = "
  520. no: .word 0
  521. sum: .word 0
  522. crlf: .byte 0xd, 0xa, 0
  523.  
  524. .text
  525. .globl main
  526.  
  527. main:
  528. li $v0, 4 # syscall 4 (print_str)
  529. la $a0, msg1 # argument: string
  530. syscall # print the string
  531.  
  532. li $v0, 5
  533. syscall
  534. sw $v0, no
  535.  
  536. li $t0, 0 # sum = 0
  537. li $t1, 1 # $t1 (i = 1)
  538. lw $t2, no # $t2 (t2 = no)
  539. next:
  540. bgt $t1, $t2, over
  541. add $t0, $t0, $t1 # sum = sum + i;
  542. addi $t1, $t1, 1 # i = i + 1
  543. j next
  544.  
  545. over:
  546. sw $t0, sum
  547.  
  548. li $v0, 4 # syscall 4 (print_str)
  549. la $a0, crlf # argument: string
  550. syscall # print the string
  551.  
  552. li $v0, 4 # syscall 4 (print_str)
  553. la $a0, msg2 # argument: string
  554. syscall # print the string
  555.  
  556. li $v0, 1
  557. lw $a0, sum
  558. syscall
  559.  
  560.  
  561.  
  562.  
  563. li $v0, 10 #
  564. syscall #
  565.  
  566. .end main
  567.  
  568.  
  569.  
  570.  
  571.  
  572.  
  573.  
  574. ####String concat hardcoded
  575. # strcat algo :
  576. # char* strcat (char * dst, char * src){
  577. # char* originalDst = dst;
  578. # while(*dst){ //i
  579. # dst++; }
  580. # while(*src){ //j
  581. # *dst = *src;
  582. # dst++;
  583. # src++;
  584. # }
  585. # *dst = *src; // = '/0'
  586. # return originalDst;
  587. # }
  588.  
  589.  
  590. .data
  591.  
  592. msg1: .asciiz "Enter String 1 : "
  593. msg2: .asciiz "Enter String 2 : "
  594. msg3: .asciiz "Concatenated String : "
  595.  
  596. str1: .asciiz "Hello"
  597. str2: .asciiz "World"
  598.  
  599. .text
  600. .globl main
  601.  
  602. main:
  603. la $a2, str1 # $a2 = *str1 = *dst
  604. la $a3, str2 # $a3 = *str2 = *src
  605.  
  606. # arguments : *str1 in $a2 and *str2 in $a3
  607. # return address in $v1
  608.  
  609. jal strcat
  610.  
  611. li $v0, 4 # print msg2
  612. la $a0, msg3
  613. syscall
  614.  
  615. li $v0, 4 # print result
  616. la $a0, 0($v1)
  617. syscall
  618.  
  619. li $v0, 10
  620. syscall
  621. .end main
  622.  
  623. strcat:
  624. li $t0, 0 # $t0 = i = 0
  625. li $t3, 0 # $t3 = j = 0
  626.  
  627. loop1:
  628. add $t1, $t0, $a2 # $t1 = addr of str1[i]
  629. lbu $t2, 0($t1) # $t2 = str1[i]
  630.  
  631. beq $t2, $zero, loop2 # if *str1 == 0 { goto loop2 }
  632.  
  633. addi $t0, $t0, 1 # i++
  634. j loop1
  635.  
  636. loop2:
  637. add $t4, $t3, $a3 # $t4 = addr of str2[i]
  638. lbu $t5, 0($t4) # $t5 = str2[i]
  639.  
  640. beq $t5, $zero, end_loop # if *str2 == 0 { goto end_loop }
  641.  
  642. sb $t5, 0($t1) # str1[i] = str2[j]
  643.  
  644. addi $t1, $t1, 1 # dst++
  645. addi $t3, $t3, 1 # src++
  646. j loop2
  647.  
  648. end_loop:
  649.  
  650. lb $t6, 0($t4) # *dst = *src = '/0'
  651. sb $t6, 0($t1)
  652.  
  653. move $v1, $a2
  654. jr $ra
  655. .end strcat
  656.  
  657.  
  658.  
  659.  
  660.  
  661. #####Linear Search
  662. .data
  663. A: .word -32, -16, 0, 8, 16, 32, 64
  664. len: .word 7
  665. data: .word 16
  666. msg1: .asciiz " found at pos: "
  667. msg2: .asciiz " not found"
  668.  
  669. .text
  670. .globl main
  671. main:
  672. lw $t0, data
  673. li $t1, 0 # isFound = 0
  674. li $t2, 0 # i in $t2
  675. lw $t3, len # len in $t3
  676. addi $t3, $t3, -1
  677. L1:
  678. bgt $t2, $t3, end_loop
  679. add $t4, $t2, $zero
  680. sll $t4, $t4, 2
  681. lw $t5, A($t4)
  682. bne $t0, $t5, not_equal
  683. li $t1, 1 # isFound = 1
  684. j end_loop
  685. not_equal:
  686. addi $t2, $t2, 1
  687. j L1
  688.  
  689. end_loop:
  690. li $v0, 1
  691. move $a0, $t0
  692. syscall
  693.  
  694. li $v0, 4
  695. beq $t1, $zero, msg_nf
  696.  
  697. la $a0, msg1
  698. syscall
  699.  
  700. li $v0, 1
  701. move $a0, $t2
  702. syscall
  703. j exit
  704.  
  705. msg_nf:
  706. la $a0, msg2
  707. syscall
  708.  
  709. exit:
  710. li $v0, 10
  711. syscall
  712. .end main
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.  
  721.  
  722. #####Leap Year
  723.  
  724. # algo for checking leap year :
  725. # (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
  726.  
  727. .data
  728. msg1: .asciiz "Enter a year : "
  729. msg2: .asciiz " is a leap year"
  730. msg3: .asciiz " is not a leap year"
  731.  
  732. .text
  733. .globl main
  734.  
  735. main:
  736. li $v0, 4
  737. la $a0, msg1
  738. syscall
  739.  
  740. li $v0, 5
  741. syscall
  742. move $t0, $v0 # year in $t0
  743.  
  744. li $t1, 4
  745. li $t2, 100
  746. li $t3, 400
  747.  
  748. div $t0, $t1 # year % 4
  749. mfhi $t1
  750.  
  751. div $t0, $t2 # year % 100
  752. mfhi $t2
  753.  
  754. div $t0, $t3 # year % 400
  755. mfhi $t3
  756.  
  757. li $v0, 1
  758. move $a0, $t0
  759. syscall
  760.  
  761. li $v0, 4
  762.  
  763. divby4:
  764. beq $t1, 0, divby100
  765. j divby400
  766.  
  767. divby100:
  768. bne $t2, 0, leapyear
  769.  
  770. divby400:
  771. beq $t3, 0, leapyear
  772. j noleapyear
  773.  
  774. leapyear:
  775. la $a0, msg2
  776. j end
  777.  
  778. noleapyear:
  779. la $a0, msg3
  780.  
  781. end:
  782. syscall
  783. li $v0, 10
  784. syscall
  785. .end main
  786.  
  787.  
  788.  
  789.  
  790.  
  791.  
  792. #####Armstrong
  793. .data
  794. msg0: .asciiz "Enter a number : "
  795. msg1: .asciiz " is"
  796. msg2: .asciiz " not"
  797. msg3: .asciiz " an armstrong number"
  798.  
  799. .text
  800. .globl main
  801.  
  802. main:
  803. li $v0, 4
  804. la $a0, msg0
  805. syscall
  806.  
  807. li $v0, 5
  808. syscall
  809. move $t4, $v0 # num in $t4
  810.  
  811. li $t0, 0 # sum in $t0
  812. move $t1, $t4 # temp in $t1
  813. li $t5, 10
  814.  
  815. loop:
  816. beq $t1, 0, endloop
  817. div $t1, $t5
  818. mflo $t1 # $t1 = temp/10
  819. mfhi $t2 # $t2 = temp%10
  820. mfhi $t3
  821.  
  822. mult $t2, $t3
  823. mflo $t3
  824. mult $t2, $t3
  825. mflo $t3 # calc cube
  826.  
  827. add $t0, $t0, $t3
  828. j loop
  829.  
  830. endloop:
  831. li $v0, 1
  832. move $a0, $t4
  833. syscall
  834.  
  835. li $v0, 4
  836. la $a0, msg1
  837. syscall
  838.  
  839. beq $t0, $t4, nextmsg # if(sum == num) { goto nextmsg }
  840. la $a0, msg2
  841. syscall
  842.  
  843. nextmsg:
  844. la $a0, msg3
  845. syscall
  846.  
  847. li $v0, 10
  848. syscall
  849. .end main
  850.  
  851.  
  852.  
  853.  
  854. ####FLOAT PROGRAMS COMPARE CONVERT
  855.  
  856. .data
  857. data1: .double 3.14
  858. data2: .double 3.14
  859. msg1: .asciiz "data1 and data2 are equal"
  860. msg2: .asciiz "data1 and data2 are not equal"
  861. .text
  862. .globl main
  863. main: l.d $f0, data1
  864. l.d $f2, data2
  865. c.eq.d $f0, $f2
  866. bc1t L1
  867. la $a0, msg2
  868. j L2
  869. L1: la $a0, msg1
  870. L2: li $v0, 4
  871. syscall
  872. li $v0, 10
  873. syscall
  874.  
  875.  
  876.  
  877. .data
  878. iNum: .word 42
  879. fNum: .float 0.0
  880. .text
  881. .globl main
  882. main: lw $t0, iNum
  883. mtc1 $t0, $f6
  884. cvt.s.w $f12, $f6
  885. s.s $f12, fNum
  886. li $v0, 2
  887. syscall
  888. li $v0, 10
  889. syscall
  890.  
  891.  
  892.  
  893. .data
  894. pi: .double 3.14
  895. intPi: .word 0
  896. .text
  897. .globl main
  898. main: l.d $f10, pi
  899. cvt.w.d $f12, $f10
  900. mfc1 $a0, $f12
  901. sw $a0, intPi
  902. li $v0, 1
  903. syscall
  904. li $v0, 10
  905. syscall
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915.  
  916.  
  917.  
  918.  
  919.  
  920.  
  921.  
  922.  
  923.  
  924. #####Sieves
  925.  
  926. #Sieve Of Eratosthenes
  927. #int sieve[101];
  928. #int n = 100;
  929. #for (int pno = 2; pno*pno <= n; pno++) {
  930. # if (sieve[pno]) {
  931. # for (int i = pno*pno; i <= n; i += pno)
  932. # sieve[i]=false;
  933. # }
  934. # }
  935.  
  936.  
  937. .data
  938. num: .word 100
  939. sieve: .space 101 #
  940. msg0: .asciiz "Checking index:"
  941. msg1: .asciiz " Val:"
  942. msg2: .asciiz " Marking Index:"
  943. msg3: .asciiz "Primes are:"
  944.  
  945.  
  946. .text
  947. .globl main
  948. main:
  949. lw $t0, num #$t0=num
  950. li $t1, 0 #i=0
  951. li $t2, 1
  952. L0:
  953. bgt $t1, $t0, begin # if ($t1 > $t0) goto begin
  954. sb $t2, sieve($t1) # sieve[i] = 1
  955. addiu $t1, $t1, 1
  956. j L0
  957.  
  958. begin:
  959. lw $t0, num #$t0=num
  960. li $t1, 2 #pno
  961. L1:
  962. multu $t1, $t1 #hi:lo=pno*pno
  963. mflo $t2 #$t2 = lo (=pno*pno)
  964. bgt $t2, $t0, end_loop # if ($t2 > $t0) then goto end_loop
  965. li $v0, 4
  966. la $a0, msg0
  967. syscall
  968. li $v0, 1
  969. move $a0, $t1
  970. syscall
  971. li $v0, 4
  972. la $a0, msg1
  973. syscall
  974. lbu $t4, sieve($t1) # $t4=sieve[pno]
  975. li $v0, 1
  976. move $a0, $t4
  977. syscall
  978. beq $t4, $zero, inc_pno # if sieve[pno]==0, skip sieving sieve[pno]
  979. li $v0, 4
  980. la $a0, msg2
  981. syscall
  982. move $t5, $t2 # $t5 = i (= pno*pno)
  983. L2:
  984. bgt $t5, $t0, inc_pno # $t5 > $t0 (i > n)
  985. li $v0, 1
  986. move $a0, $t5
  987. syscall
  988. li $v0, 11
  989. li $a0, ' '
  990. syscall
  991. sb $zero, sieve($t5) # sieve[pno] = 0
  992. addu $t5, $t5, $t1 # $t5 = $t5 + $t1 (i+=pno)
  993. j L2
  994. inc_pno:
  995. li $v0, 11
  996. li $a0, '\n'
  997. syscall
  998. addiu $t1, $t1, 1 # $t1++ (=pno++)
  999. j L1
  1000. end_loop:
  1001.  
  1002. li $v0, 11
  1003. li $a0, '\n'
  1004. syscall
  1005.  
  1006. li $v0, 4
  1007. la $a0, msg3
  1008. syscall
  1009.  
  1010. li $t2, 2 #i=2
  1011. L3:
  1012. bgt $t2, $t0, over # i>n
  1013. lb $t3, sieve($t2) # $t3=sieve[i]
  1014. beq $t3, $zero, inc_i # if sieve[i]==0 then next_i
  1015.  
  1016. li $v0, 1
  1017. move $a0, $t2 # $v0=1, $a0 = i (sieve[i]==1)
  1018. syscall # print the num
  1019.  
  1020. li $v0, 11
  1021. li $a0, ' '
  1022. syscall
  1023.  
  1024. inc_i:
  1025. addiu $t2, $t2, 1
  1026. j L3
  1027.  
  1028. over:
  1029. li $v0, 11
  1030. li $a0, '\n'
  1031. syscall
  1032. li $v0, 10
  1033. syscall
  1034.  
  1035. #Sieve Of Eratosthenes
  1036. #unsigned char sieve[101];
  1037. #int n = 100;
  1038. #for (int pno = 2; pno*pno <= n; pno++) {
  1039. # if (sieve[pno]) {
  1040. # for (int i = pno*pno; i <= n; i += pno)
  1041. # sieve[i]=false; //Marking Index
  1042. # }
  1043. # }
  1044.  
  1045.  
  1046.  
  1047.  
  1048.  
  1049.  
  1050.  
  1051.  
  1052.  
  1053.  
  1054.  
  1055.  
  1056.  
  1057.  
  1058. ####FPTR
  1059.  
  1060. .data
  1061. x: .word 10
  1062. y: .word 6
  1063. z: .word 0
  1064. op: .word 2 #ADD=0, SUB=1, etc.
  1065.  
  1066. plus_str: .asciiz " PLUS "
  1067. minus_str:.asciiz " MINUS "
  1068. mul_str: .asciiz " MUL "
  1069. div_str: .asciiz " DIV "
  1070. mod_str: .asciiz " MOD "
  1071. equ_str: .asciiz " = "
  1072.  
  1073. # addresses of functions (array of func pointers)
  1074. # int (*fptr[])(int, int) = { f_add, f_sub, f_mul, d_div, f_mod};
  1075.  
  1076. fptrs:
  1077. .word f_add, f_sub, f_mul, f_div, f_mod
  1078.  
  1079. # addresses of strs (array of char *)
  1080. # char *op_str[] = {"PLUS", "MINUS", "MUL", "DIV", "MOD"};
  1081. op_str:
  1082. .word plus_str, minus_str, mul_str, div_str, mod_str
  1083.  
  1084.  
  1085. .text
  1086. .globl main
  1087.  
  1088. main:
  1089. lw $a0, x # arg 1
  1090. lw $a1, y # arg 2
  1091. lw $a2, op # op = ADD (0), SUB(1) etc
  1092. jal do_op # call do_op( z = fptr[0](x,y))
  1093. sw $v0, z # z = $v0
  1094.  
  1095. li $v0, 1 # print int
  1096. lw $a0, x # $a0 = x
  1097. syscall
  1098.  
  1099. li $v0, 4 # print str
  1100. lw $t0, op # op = ADD (0), SUB(1) etc
  1101. sll $t0, $t0, 2 # $t0 = $t0 * 4 (size of addr)
  1102. lw $a0, op_str($t0) # $a0 = addr(plus), addr(minus) etc
  1103. syscall
  1104.  
  1105. li $v0, 1 # print int
  1106. lw $a0, y # $a0 = y
  1107. syscall
  1108.  
  1109. li $v0, 4 # print str
  1110. la $a0, equ_str # equ_str: "="
  1111. syscall
  1112.  
  1113. li $v0, 1 # print int
  1114. lw $a0, z # $a0 = z (result)
  1115. syscall
  1116.  
  1117. li $v0, 10 # exit
  1118. syscall
  1119.  
  1120. do_op:
  1121. addi $sp, $sp, -4 # make place to save ra
  1122. sw $ra, 0($sp) # save ra
  1123.  
  1124. sll $t0, $a2, 2 # $t0 = $a0 << 4 (size of a ptr)
  1125. lw $t1, fptrs($t0) # $t1 = fptrs[i] (addr of func)
  1126. jalr $t1 # jmp to the function pointed by $t1
  1127. lw $ra, 0($sp) # retrive the return add
  1128. addi $sp, $sp, 4 # restore sp
  1129. jr $ra # return
  1130.  
  1131. f_add:
  1132. add $v0, $a0, $a1 # add: result in $v0
  1133. jr $ra # return
  1134.  
  1135. f_sub:
  1136. sub $v0, $a0, $a1
  1137. jr $ra
  1138.  
  1139. f_mul:
  1140. mul $v0, $a0, $a1
  1141. jr $ra
  1142.  
  1143.  
  1144. f_div:
  1145. div $v0, $a0, $a1
  1146. jr $ra
  1147.  
  1148. f_mod:
  1149. rem $v0, $a0, $a1
  1150. jr $ra
  1151.  
  1152.  
  1153.  
  1154.  
  1155. ####Matrix Operation
  1156. #X = X + Y × Z
  1157. #4 × 4 matrices, 64-bit double-precision elements
  1158. #void mm (double x[][],double y[][], double z[][])
  1159. #{ int i, j, k;
  1160. # for (i = 0; i! = 32; i = i + 1)
  1161. # for (j = 0; j! = 32; j = j + 1)
  1162. # for (k = 0; k! = 32; k = k + 1)
  1163. # x[i][j] = x[i][j] + y[i][k] * z[k][j];
  1164. #}
  1165. #Addresses of x, y, z in $a0, $a1, $a2, and i, j, k in $s0, $s1, $s2
  1166.  
  1167. .data
  1168. X: .double 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0
  1169. Y: .double 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0
  1170. Z: .double 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0
  1171.  
  1172. .text
  1173. .globl main
  1174. main: li $t1, 4 # $t1 = 4 (row size/loop end)
  1175. li $s0, 0 # i = 0; initialize 1st for loop
  1176. L1: li $s1, 0 # j = 0; restart 2nd for loop
  1177. L2: li $s2, 0 # k = 0; restart 3rd for loop
  1178. sll $t2, $s0, 2 # $t2 = i * 4 (size of row of x)
  1179. addu $t2, $t2, $s1 # $t2 = i * size(row) + j
  1180. sll $t2, $t2, 3 # $t2 = byte offset of [i][j] 8 bytes *8 =
  1181. la $a0, X
  1182. addu $t2, $a0, $t2 # $t2 = byte address of x[i][j]
  1183. l.d $f4, 0($t2) # $f4 = 8 bytes of x[i][j]
  1184. L3: sll $t0, $s2, 2 # $t0 = k * 32 (size of row of z)
  1185. addu $t0, $t0, $s1 # $t0 = k * size(row) + j
  1186. sll $t0, $t0, 3 # $t0 = byte offset of [k][j]
  1187. la $a2, Z
  1188. addu $t0, $a2, $t0 # $t0 = byte address of z[k][j]
  1189. l.d $f16, 0($t0) # $f16 = 8 bytes of z[k][j]
  1190. sll $t0, $s0, 2 # $t0 = i*32 (size of row of y)
  1191. addu $t0, $t0, $s2 # $t0 = i*size(row) + k
  1192. sll $t0, $t0, 3 # $t0 = byte offset of [i][k]
  1193. la $a1, Y
  1194. addu $t0, $a1, $t0 # $t0 = byte address of y[i][k]
  1195. l.d $f18, 0($t0) # $f18 = 8 bytes of y[i][k]
  1196. mul.d $f16, $f18, $f16 # $f16 = y[i][k] * z[k][j]
  1197. add.d $f4, $f4, $f16 # f4=x[i][j] + y[i][k]*z[k][j]
  1198. addiu $s2, $s2, 1 # $k k + 1
  1199. bne $s2, $t1, L3 # if (k != 32) go to L3
  1200. s.d $f4, 0($t2) # x[i][j] = $f4
  1201. addiu $s1, $s1, 1 # $j = j + 1
  1202. bne $s1, $t1, L2 # if (j != 32) go to L2
  1203. addiu $s0, $s0, 1 # $i = i + 1
  1204. bne $s0, $t1, L1 # if (i != 32) go to L1
  1205. li $v0, 2
  1206. mov.s $f12,$f4
  1207. syscall
  1208. li $v0, 10
  1209. syscall
  1210.  
  1211.  
  1212.  
  1213. ####Float polynomial
  1214. .data
  1215. a: .float 1.0
  1216. bb: .float 2.0
  1217. c: .float 3.0
  1218.  
  1219. msg: .asciiz "Enter x: "
  1220. blank: .asciiz " "
  1221. newl: .asciiz "\n"
  1222. .text
  1223. .globl main
  1224.  
  1225. # Register Use Chart
  1226. # $f0 -- x
  1227. # $f2 -- sum of terms
  1228.  
  1229. main: # read input
  1230. la $a0,msg # prompt user for x
  1231. li $v0,4 # print string
  1232. syscall
  1233.  
  1234. li $v0,6 # read single
  1235. syscall # $f0 <-- x
  1236.  
  1237. # evaluate the quadratic
  1238. l.s $f2,a # sum = a
  1239. mul.s $f2,$f2,$f0 # sum = ax
  1240. l.s $f4,bb # get b
  1241. add.s $f2,$f2,$f4 # sum = ax + b
  1242. mul.s $f2,$f2,$f0 # sum = (ax+b)x = ax^2 +bx
  1243. l.s $f4,c # get c
  1244. add.s $f2,$f2,$f4 # sum = ax^2 + bx + c
  1245.  
  1246. # print the result
  1247. mov.s $f12,$f2 # $f12 = argument
  1248. li $v0,2 # print single
  1249. syscall
  1250.  
  1251. la $a0,newl # new line
  1252. li $v0,4 # print string
  1253. syscall
  1254.  
  1255. li $v0,10 # code 10 == exit
  1256. syscall # Return to OS.
  1257.  
  1258.  
  1259.  
  1260.  
  1261.  
  1262.  
  1263.  
  1264. #####Ghanoi
  1265. # void hanoi(int ndisks, from, to, using)
  1266. # if (ndisks == 1) {
  1267. # printf("Moving disk %d from %c to %c\n", ndisks, from to);
  1268. # return
  1269. # }
  1270. # hanoi(ndisks-1, from, using, to);
  1271. # printf("Moving disk %d from %c to %c\n", ndisks, from to);
  1272. # hanoi(ndisks-1, using, to, from);
  1273. #
  1274. #
  1275. #
  1276. .data
  1277. n: .word 4
  1278. move_msg: .asciiz "Moving Disk: "
  1279. from_msg: .asciiz " From Pole: "
  1280. to_msg: .asciiz " To Pole: "
  1281. eoln: .byte '\n'
  1282.  
  1283. .text
  1284. .globl main
  1285. main:
  1286. lw $a0, n # $a0 = n (ndisks)
  1287. li $a1, 'A' # from Pole
  1288. li $a2, 'B' # to Pole
  1289. li $a3, 'C' # using pole
  1290. jal hanoi #
  1291.  
  1292. li $v0, 10 # decent good bye
  1293. syscall #
  1294.  
  1295. # void hanoi(int ndisks, from, to, using)
  1296. # $a0, $a1, $a2, $a3
  1297. hanoi:
  1298. add $sp, $sp, -20
  1299. sw $ra, 0($sp) # push ret add
  1300. sw $a0, 4($sp) # ndisks
  1301. sw $a1, 8($sp) # from pole
  1302. sw $a2, 12($sp) # to pole
  1303. sw $a3, 16($sp) # using pole
  1304.  
  1305. addi $t0, $zero, 1 #
  1306. bgt $a0, $t0, L1 # if ndisks($a0>1) then L1
  1307.  
  1308. # printf("Moving disk %d from pole %c to pole %c\n", ndisks, from to);
  1309. jal print
  1310.  
  1311. lw $ra, 0($sp) # retrive return address
  1312. addi $sp, $sp, 20 # restore sp
  1313. jr $ra # and return
  1314.  
  1315.  
  1316. L1: # if ndisks($a0)>1 ...
  1317. addi $a0, $a0, -1 # ndisks = ndisks-1
  1318. move $t0, $a2 # tmp = to ($a2)
  1319. move $a2, $a3 # to($a2) = $a3 (using)
  1320. move $a3, $t0 # to(a3) = tmp
  1321. jal hanoi # hanoi(ndisks-1, from, using, to);
  1322.  
  1323. lw $a0, 4($sp) # retrive ndisks
  1324. lw $a1, 8($sp) # from
  1325. lw $a2, 12($sp) # to
  1326. jal print
  1327.  
  1328. lw $a0, 4($sp) # retrive ndisks
  1329. addi $a0, $a0, -1 # ndisks = ndisks-1
  1330.  
  1331. lw $a1, 16($sp) # from
  1332. lw $a2, 12($sp) # to
  1333. lw $a3, 8($sp) # using
  1334. jal hanoi # hanoi(ndisks-1, using, to, from);
  1335.  
  1336. lw $ra, 0($sp) # retrive return address
  1337. addi $sp, $sp, 20 # restore sp
  1338. jr $ra # and return
  1339.  
  1340.  
  1341. #printf("Moving disk %d from %c to %c\n", ndisks, from to);
  1342. print:
  1343. move $s0, $a0 # disk no
  1344. move $s1, $a1 # from
  1345. move $s2, $a2 # to
  1346.  
  1347. li $v0, 4 # print_string
  1348. la $a0, move_msg # "Moving disk "
  1349. syscall
  1350.  
  1351. li $v0, 1 # print_int
  1352. move $a0, $s0 # disk no
  1353. syscall
  1354.  
  1355. li $v0, 4 # print_string
  1356. la $a0, from_msg # "from pole"
  1357. syscall
  1358.  
  1359. li $v0, 11 # print_char
  1360. move $a0, $s1 # from pole ($s1)
  1361. syscall
  1362.  
  1363. li $v0, 4 # print_string
  1364. la $a0, to_msg # "to pole"
  1365. syscall
  1366.  
  1367. li $v0, 11 # print_char
  1368. move $a0, $s2 # to
  1369. syscall
  1370.  
  1371. li $v0, 11 # print_char
  1372. lb $a0, eoln # '\n'
  1373. syscall
  1374.  
  1375. jr $ra # return to caller
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!