<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  <channel>
    <title>'Merge Sort MIPS Assembly help with stack pointer' Thread RSS Feed</title>
    <link>http://www.programmersheaven.com/</link>
    <description>Contains the latest posts from the thread 'Merge Sort MIPS Assembly help with stack pointer' posted on the 'Assembler Developer' forum at Programmer's Heaven.</description>
    <language>en</language>
    <copyright>Copyright 2013 Programmers Heaven</copyright>
    <pubDate>Wed, 19 Jun 2013 18:13:06 -0700</pubDate>
    <lastBuildDate>Wed, 19 Jun 2013 18:13:06 -0700</lastBuildDate>
    <generator>Argotic Syndication Framework 2007.3.0.1, http://www.codeplex.com/Argotic</generator>
    <docs>http://www.rssboard.org/rss-specification</docs>
    <ttl>360</ttl>
    <image>
      <url>http://www.programmersheaven.com/images/ph.gif</url>
      <title>Programmers Heaven</title>
      <link>http://www.programmersheaven.com/</link>
      <width>88</width>
      <height>31</height>
    </image>
    <item>
      <title>Merge Sort MIPS Assembly help with stack pointer</title>
      <link>http://www.programmersheaven.com/mb/pharabee/427937/427937/merge-sort-mips-assembly-help-with-stack-pointer/</link>
      <description>I am in some need of some desperate help at the moment. I have a merge sort program running in MIPS assembly and I am almost complete. I have a few issues with my pointer, but I cannot seem to find them. If anyone would help that will be much appreciative. &lt;br /&gt;
Feel free to ask me if uncertain what is going on in a certain place.&lt;br /&gt;
Thanks in advance!&lt;br /&gt;
&lt;pre class="sourcecode"&gt;
main:
                li      $s0,    0
                addi    $s1,    $s1,    19      # $s1=hi
                addi    $s0,    $s0,    0       # $s0=lo

                la      $a0,    list
                addi    $s2,    $s2,    0

                addi    $sp,    $sp,    -20
                sw      $ra,    16($sp)
                sw      $a0,    12($sp)
                sw      $s2,    8($sp)          # m
                sw      $s1,    4($sp)          # hi
                sw      $s0,    0($sp)          # lo
                jal     merge_sort

merge_sort:
                add     $t0,    $s0,    $s1     # t0 = lo+hi
                div     $s2,    $t0,    2       # m=lo+hi/2
                
                slt     $t0,    $s0,    $s1     # $t0=1 if lo&amp;lt;hi
                bne     $t0,    $zero,  L1      # if lo&amp;lt;hi branch to L1

                jr      $ra  

L1:
                
                addi    $sp,    $sp,    -20
                sw      $ra,    16($sp)
                sw      $a0,    12($sp)
                sw      $s2,    8($sp)          # m
                sw      $s1,    4($sp)          # hi    
                sw      $s0,    0($sp)          # lo


                add     $s1,    $s2,    $zero             # hi=m
    
    
                jal     merge_sort              # merge_sort(a(a0), ?, $s0,    $
L2:
    
                addi    $sp,    $sp,    -20
               sw      $ra,    16($sp)
  #              sw      $a0,    12($sp)
   #             sw      $s2,    8($sp)          # m
    #            sw      $s1,    4($sp)          # hi
     #           sw      $s0,    0($sp)          # lo
                addi    $s0,    $s1,    1
                
                jal     merge_sort
                
                addi    $sp,    $sp,    20
                
                lw      $s0,    0($sp)
                lw      $s1,    4($sp)
                lw      $s2,    8($sp)
                lw      $a0,    12($sp)

                jal     merge

   
                lw      $s0,    0($sp)
##              lw      $s1,    4($sp)
                lw      $s2,    8($sp) 
                lw      $a0,    12($sp)
    
                lw      $ra,    16($sp)  
                addi    $sp,    $sp,    20
                
                jr      $ra
                
#########################################
merge:
                li      $t2,    0               # i
                li      $t3,    0               # j
                li      $t4,    0               # k
                
                move     $t2,   $s0     # i=lo
  
##FOR LOOP FROM MERGE###
########################

        for:
                slt     $t1,    $s1,    $t2     # $t1=1;hi&amp;lt;i
                bne     $t1,    $zero,  next    #if i&amp;gt;hi next loop
                
                la      $a0,    list            # array list into $a0
                move    $t5,    $t2             # save iterator
                sll     $t5,    $t5,    2       # shift by 4
                add     $t6,    $t5,    $a0     # $t6=a[i]
                lw      $t1,    0($t6)   

                la      $a0,    b_array
                move    $t7,    $t2
                sll     $t7,    $t7,    2       # shift 4
                add     $t7,    $t7,    $a0
                sw      $t1,    0($t7)          # $b[i]=a[i]

                addi    $t2,    $t2,    1
                
                j       for
                
                
###START OF WHILE LOOP 1####
                
        next:   
                move    $t2,    $s0             # i=lo
                addi    $t3,    $s2,    1       # j=m+1 (Hopefully)
                move    $t4,    $s0             # k=lo
                
        while1:
                slt     $t1,    $s2,    $t2     #$t1=1;m&amp;lt;i
                bne     $t1,    $zero,  while2  #ifm&amp;lt;i branch to while2
  
                slt     $t1,    $s1,    $t3     #$t1=1;hi&amp;lt;j
                bne     $t1,    $zero,  while2  #if j&amp;gt;hi branch to while2

#####           getting b[i] &amp;amp; storing into $s3 #######
                
                move    $t5,    $t2             #preserve i into $t5
                
                la      $a0,    b_array
                sll     $t5,    $t5,    2
                add     $t6,    $t5,    $a0     #load b[i] into $t6
                lw      $s3,    0($t6)          #load content of b[i] into $s3
                
 ###Getting element b[j] &amp;amp; storing into $s4########
                
                la      $a0,    b_array
                move    $t7,    $t3             #preserve j
                sll     $t7,    $t7,    2       #j*4
                add     $t6     $t7,    $a0     #b[j]=$t6   
                lw      $s4,    0($t6)          #content of b[j] into $s4
                
####Compare value of $s3 &amp;amp; $s4#######

        if:     slt     $t1,    $s4,    $s3     #$t1=1 if b[j]&amp;lt;b[j]
                bne     $t1,    $zero,  else    #if b[i]&amp;gt;b[j] branch to else

####copy b[i++] into a[k++]
        
        ##b[i++]##
                la      $a0,    b_array
                move    $t5,    $t2             # preserve i
                sll     $t5,    $t5,    2       # shift address *4
                add     $t6,    $t5,    $a0
                lw      $t0,    0($t6)          # load element into $t0
                
        ##a[k++]##
                la      $a0,    list
                move    $t5,    $t4             #preserve k
                sll     $t5,    $t5,    2       #shift by 4
                add     $t6,    $t5,    $a0
                sw      $t0,    0($t6)          # a[k++]=b[i++]
                
                addi    $t2,    $t2,    1       #i++
                addi    $t4,    $t4,    1       #k++
                j       while1
                
###else b[j++]---&amp;gt;a[k++]###
        else:   
 
        ##b[j++]##
                
                la      $a0,    b_array
                move    $t5,    $t3             # preserve j
                sll     $t5,    $t5,    2       # shift 4   
                add     $t6,    $t5,    $a0     # load into $t6
                lw      $t0,    0($t6)          # $t6--&amp;gt;$t0

        ##a[k++]
        
                la      $a0,    list
                move    $t5,    $t4             #preserve k
                sll     $t5,    $t5,    2       #shift 4
                add     $t6,    $t5,    $a0     #load into $t6
                sw      $t0,    0($t6)          # $t0--&amp;gt;0($t6)
                
                addi    $t3,    $t3,    1       #j++
                addi    $t4,    $t4,    1       #k++
                j       while1
                
        while2: 
                slt     $t1,    $s2,    $t2             #$t1=1;m&amp;lt;i
                bne     $t1,    $zero,  end_merge       #ifm&amp;lt;i branch to end_me$
                
###a[k++]=b[i++]###
                
                la      $a0,    b_array
                move    $t5,    $t2             # preserve i
                sll     $t5,    $t5,    2       # shift address *4
                add     $t6,    $t5,    $a0
                lw      $t0,    0($t6)
                
                la      $a0,    list
                move    $t5,    $t4
                sll     $t5,    $t5,    2
                add     $t6,    $t5,    $a0
                sw      $t0,    0($t6)           # a[k++]
                
                addi    $t2,    $t2,    1       #i++
                addi    $t4,    $t4,    1
                j       while2
                
end_merge:

  
                j       $ra             #jump to previous location


&lt;/pre&gt;&lt;br /&gt;</description>
      <guid isPermaLink="true">http://www.programmersheaven.com/mb/pharabee/427937/427937/merge-sort-mips-assembly-help-with-stack-pointer/</guid>
      <pubDate>Tue, 20 Mar 2012 21:15:39 -0700</pubDate>
      <category>Assembler Developer</category>
    </item>
  </channel>
</rss>