components/clisp/patches/arisparc64.d.patch
author Mike Sullivan <Mike.Sullivan@Oracle.COM>
Wed, 29 Aug 2012 11:05:56 -0700
changeset 957 255465c5756f
parent 328 38a06e74a699
permissions -rw-r--r--
Close of build 04.
--- src.orig/arisparc64.d	Thu Dec  6 00:06:32 2007
+++ src/arisparc64.d	Mon Feb  2 15:35:22 2009
@@ -75,9 +75,9 @@
 
 # extern struct { uint32 lo; uint32 hi; } mulu32_ (uint32 arg1, uint32 arg2);
 # 2^32*hi+lo := arg1*arg2.
-C(mulu32_:) # Input in %o0,%o1, Output in %o0,%g1
+C(mulu32_:) # Input in %o0,%o1, Output in %o0,%g3
         umul %o0,%o1,%o2
-        rd %y,%g1
+        rd %y,%g3
         retl
        _ srl %o2,0,%o0
 
@@ -90,11 +90,11 @@
 
 # extern struct { uint32 q; uint32 r; } divu_6432_3232_ (uint32 xhi, uint32 xlo, uint32 y);
 # x = 2^32*xhi+xlo = q*y+r schreiben. Sei bekannt, dass 0 <= x < 2^32*y .
-C(divu_6432_3232_:) # Input in %o0,%o1,%o2, Output in %o0,%g1
+C(divu_6432_3232_:) # Input in %o0,%o1,%o2, Output in %o0,%g3
         wr %o0,%g0,%y
         udiv %o1,%o2,%o0        # x durch y dividieren, %o0 := q
-        umul %o0,%o2,%g1        # %g1 := (q*y) mod 2^32
-        sub %o1,%g1,%g1         # %g1 := (xlo-q*y) mod 2^32 = r
+        umul %o0,%o2,%g3        # %g3 := (q*y) mod 2^32
+        sub %o1,%g3,%g3         # %g3 := (xlo-q*y) mod 2^32 = r
         retl
        _ srl %o0,0,%o0
 
@@ -104,13 +104,13 @@
         wr %g0,%g0,%y
         udiv %o0,%o1,%o2        # dividieren, Quotient nach %o2
 #if 0 # Who says that %y has some meaningful contents after `udiv' ??
-        rd %y,%g1               # Rest aus %y
+        rd %y,%g3               # Rest aus %y
 #else
-        umul %o2,%o1,%g1        # %g1 := (q*y) mod 2^32
-        sub %o0,%g1,%g1         # %g1 := (x-q*y) mod 2^32 = r
+        umul %o2,%o1,%g3        # %g3 := (q*y) mod 2^32
+        sub %o0,%g3,%g3         # %g3 := (x-q*y) mod 2^32 = r
 #endif
-        sll %g1,16,%g1          # in die oberen 16 Bit schieben
-        or %o2,%g1,%o0
+        sll %g3,16,%g3          # in die oberen 16 Bit schieben
+        or %o2,%g3,%o0
         retl
        _ srl %o0,0,%o0
 
@@ -713,28 +713,28 @@
 #endif
 
 # extern uintD add_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
-C(add_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1, Output in %o0
+C(add_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3, Output in %o0
 #if STANDARD_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ mov %g0,%g1            # Carry := 0
+       _ mov %g0,%g3            # Carry := 0
 1:        sub %o0,4,%o0
           lduw [%o0],%o4        # source1-digit, zero-extend
           sub %o1,4,%o1
           lduw [%o1],%o5        # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          add %g1,%o5,%g1       # zum Carry addieren
-          st %g1,[%o2]          # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          add %g3,%o5,%g3       # zum Carry addieren
+          st %g3,[%o2]          # Digit ablegen
           subcc %o3,1,%o3
           bne,pt %xcc,1b
-         _ srlx %g1,32,%g1      # neuer Carry
+         _ srlx %g3,32,%g3      # neuer Carry
 2:      retl
-       _ mov %g1,%o0
+       _ mov %g3,%o0
 #endif
 #if COUNTER_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ mov %g0,%g1            # Carry := 0
+       _ mov %g0,%g3            # Carry := 0
         sub %o0,4,%o0
         sub %o1,4,%o1
         sllx %o3,2,%o3          # %o3 = 4*count
@@ -743,14 +743,14 @@
         sub %o2,%o3,%o2         # %o2 = &destptr[-count]
 1:        lduw [%o0+%o3],%o4    # source1-digit, zero-extend
           lduw [%o1+%o3],%o5    # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          add %g1,%o5,%g1       # zum Carry addieren
-          st %g1,[%o2+%o3]      # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          add %g3,%o5,%g3       # zum Carry addieren
+          st %g3,[%o2+%o3]      # Digit ablegen
           subcc %o3,4,%o3
           bne,pt %xcc,1b
-         _ srlx %g1,32,%g1      # neuer Carry
+         _ srlx %g3,32,%g3      # neuer Carry
 2:      retl
-       _ mov %g1,%o0
+       _ mov %g3,%o0
 #endif
 
 # extern uintD addto_loop_down (uintD* sourceptr, uintD* destptr, uintC count);
@@ -831,28 +831,28 @@
 #endif
 
 # extern uintD sub_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
-C(sub_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1, Output in %o0
+C(sub_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3, Output in %o0
 #if STANDARD_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ mov %g0,%g1            # Carry := 0
+       _ mov %g0,%g3            # Carry := 0
 1:        sub %o0,4,%o0
           lduw [%o0],%o4        # source1-digit, zero-extend
           sub %o1,4,%o1
           lduw [%o1],%o5        # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          sub %g1,%o5,%g1       # vom Carry subtrahieren
-          st %g1,[%o2]          # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          sub %g3,%o5,%g3       # vom Carry subtrahieren
+          st %g3,[%o2]          # Digit ablegen
           subcc %o3,1,%o3
           bne,pt %xcc,1b
-         _ srax %g1,32,%g1      # neuer Carry
+         _ srax %g3,32,%g3      # neuer Carry
 2:      retl
-       _ srl %g1,0,%o0
+       _ srl %g3,0,%o0
 #endif
 #if COUNTER_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ mov %g0,%g1            # Carry := 0
+       _ mov %g0,%g3            # Carry := 0
         sub %o0,4,%o0
         sub %o1,4,%o1
         sllx %o3,2,%o3          # %o3 = 4*count
@@ -861,39 +861,39 @@
         sub %o2,%o3,%o2         # %o2 = &destptr[-count]
 1:        lduw [%o0+%o3],%o4    # source1-digit, zero-extend
           lduw [%o1+%o3],%o5    # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          sub %g1,%o5,%g1       # vom Carry subtrahieren
-          st %g1,[%o2+%o3]      # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          sub %g3,%o5,%g3       # vom Carry subtrahieren
+          st %g3,[%o2+%o3]      # Digit ablegen
           subcc %o3,4,%o3
           bne,pt %xcc,1b
-         _ srax %g1,32,%g1      # neuer Carry
+         _ srax %g3,32,%g3      # neuer Carry
 2:      retl
-       _ srl %g1,0,%o0
+       _ srl %g3,0,%o0
 #endif
 
 # extern uintD subx_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count, uintD carry);
-C(subx_loop_down:) # Input in %o0,%o1,%o2,%o3,%o4, verändert %g1, Output in %o0
+C(subx_loop_down:) # Input in %o0,%o1,%o2,%o3,%o4, verändert %g3, Output in %o0
 #if STANDARD_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ sra %o4,0,%g1          # Carry, sign-extend
+       _ sra %o4,0,%g3          # Carry, sign-extend
 1:        sub %o0,4,%o0
           lduw [%o0],%o4        # source1-digit, zero-extend
           sub %o1,4,%o1
           lduw [%o1],%o5        # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          sub %g1,%o5,%g1       # vom Carry subtrahieren
-          st %g1,[%o2]          # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          sub %g3,%o5,%g3       # vom Carry subtrahieren
+          st %g3,[%o2]          # Digit ablegen
           subcc %o3,1,%o3
           bne,pt %xcc,1b
-         _ srax %g1,32,%g1      # neuer Carry
+         _ srax %g3,32,%g3      # neuer Carry
 2:      retl
-       _ srl %g1,0,%o0
+       _ srl %g3,0,%o0
 #endif
 #if COUNTER_LOOPS
 #       srl %o3,0,%o3           # zero-extend %o3 = count
         brz,pn %o3,2f
-       _ sra %o4,0,%g1          # Carry, sign-extend
+       _ sra %o4,0,%g3          # Carry, sign-extend
         sub %o0,4,%o0
         sub %o1,4,%o1
         sllx %o3,2,%o3          # %o3 = 4*count
@@ -902,14 +902,14 @@
         sub %o2,%o3,%o2         # %o2 = &destptr[-count]
 1:        lduw [%o0+%o3],%o4    # source1-digit, zero-extend
           lduw [%o1+%o3],%o5    # source2-digit, zero-extend
-          add %g1,%o4,%g1       # zum Carry addieren
-          sub %g1,%o5,%g1       # vom Carry subtrahieren
-          st %g1,[%o2+%o3]      # Digit ablegen
+          add %g3,%o4,%g3       # zum Carry addieren
+          sub %g3,%o5,%g3       # vom Carry subtrahieren
+          st %g3,[%o2+%o3]      # Digit ablegen
           subcc %o3,4,%o3
           bne,pt %xcc,1b
-         _ srax %g1,32,%g1      # neuer Carry
+         _ srax %g3,32,%g3      # neuer Carry
 2:      retl
-       _ srl %g1,0,%o0
+       _ srl %g3,0,%o0
 #endif
 
 # extern uintD subfrom_loop_down (uintD* sourceptr, uintD* destptr, uintC count);
@@ -1135,16 +1135,16 @@
 #endif
 
 # extern uintD shiftright_loop_up (uintD* ptr, uintC count, uintC i);
-C(shiftright_loop_up:) # Input in %o0,%o1,%o2, verändert %g1, Output in %o0
+C(shiftright_loop_up:) # Input in %o0,%o1,%o2, verändert %g3, Output in %o0
 #ifdef SLOWER
 #       srl %o1,0,%o1           # zero-extend %o1 = count
         brz,pn %o1,2f
        _ or %g0,%g0,%o3         # Carry := 0
-        mov 32,%g1
-        sub %g1,%o2,%g1         # 32-i
+        mov 32,%g3
+        sub %g3,%o2,%g3         # 32-i
 1:        lduw [%o0],%o4        # Digit, zero-extend
           subcc %o1,1,%o1
-          sllx %o4,%g1,%o4      # shiften
+          sllx %o4,%g3,%o4      # shiften
           or %o3,%o4,%o3        # und mit altem Carry kombinieren
           srlx %o3,32,%o4
           st %o4,[%o0]          # und ablegen
@@ -1157,13 +1157,13 @@
 #       srl %o1,0,%o1           # zero-extend %o1 = count
         brz,pn %o1,2f
        _ or %g0,%g0,%o3         # Carry := 0
-        sub %g0,%o2,%g1         # 32-i (mod 32)
+        sub %g0,%o2,%g3         # 32-i (mod 32)
 1:        ld [%o0],%o4          # Digit
           subcc %o1,1,%o1
           srl %o4,%o2,%o5       # shiften
           or %o3,%o5,%o5        # und mit altem Carry kombinieren
           st %o5,[%o0]          # und ablegen
-          sll %o4,%g1,%o3       # neuer Carry
+          sll %o4,%g3,%o3       # neuer Carry
           bne,pt %xcc,1b
          _ add %o0,4,%o0
 2:      retl
@@ -1171,14 +1171,14 @@
 #endif
 
 # extern uintD shiftrightsigned_loop_up (uintD* ptr, uintC count, uintC i);
-C(shiftrightsigned_loop_up:) # Input in %o0,%o1,%o2, verändert %g1, Output in %o0
+C(shiftrightsigned_loop_up:) # Input in %o0,%o1,%o2, verändert %g3, Output in %o0
 #ifdef SLOWER
 #       srl %o1,0,%o1           # zero-extend %o1 = count
-        mov 32,%g1
-        sub %g1,%o2,%g1         # 32-i
+        mov 32,%g3
+        sub %g3,%o2,%g3         # 32-i
         ldsw [%o0],%o3          # erstes Digit, sign-extend
         subcc %o1,1,%o1
-        sllx %o3,%g1,%o3        # shiften
+        sllx %o3,%g3,%o3        # shiften
         srlx %o3,32,%o4
         st %o4,[%o0]            # und ablegen
         sllx %o3,32,%o3         # neuer Carry
@@ -1186,7 +1186,7 @@
        _ add %o0,4,%o0
 1:        lduw [%o0],%o4        # Digit, zero-extend
           subcc %o1,1,%o1
-          sllx %o4,%g1,%o4      # shiften
+          sllx %o4,%g3,%o4      # shiften
           or %o3,%o4,%o3        # und mit altem Carry kombinieren
           srlx %o3,32,%o4
           st %o4,[%o0]          # und ablegen
@@ -1198,10 +1198,10 @@
 #else
 #       srl %o1,0,%o1           # zero-extend %o1 = count
         ld [%o0],%o4            # erstes Digit
-        sub %g0,%o2,%g1         # 32-i (mod 32)
+        sub %g0,%o2,%g3         # 32-i (mod 32)
         sra %o4,%o2,%o5         # shiften
         st %o5,[%o0]            # und ablegen
-        sll %o4,%g1,%o3         # neuer Carry
+        sll %o4,%g3,%o3         # neuer Carry
         subcc %o1,1,%o1
         be,pn %xcc,2f
        _ add %o0,4,%o0
@@ -1210,7 +1210,7 @@
           srl %o4,%o2,%o5       # shiften
           or %o3,%o5,%o5        # und mit altem Carry kombinieren
           st %o5,[%o0]          # und ablegen
-          sll %o4,%g1,%o3       # neuer Carry
+          sll %o4,%g3,%o3       # neuer Carry
           bne,pt %xcc,1b
          _ add %o0,4,%o0
 2:      retl
@@ -1218,16 +1218,16 @@
 #endif
 
 # extern uintD shiftrightcopy_loop_up (uintD* sourceptr, uintD* destptr, uintC count, uintC i, uintD carry);
-C(shiftrightcopy_loop_up:) # Input in %o0,%o1,%o2,%o3,%o4, verändert %g1,%g2, Output in %o0
+C(shiftrightcopy_loop_up:) # Input in %o0,%o1,%o2,%o3,%o4, verändert %g3,%g2, Output in %o0
 #ifdef SLOWER
 #       srl %o2,0,%o2           # zero-extend %o2 = count
-        sub %g0,%o3,%g1         # 64-i (mod 64)
+        sub %g0,%o3,%g3         # 64-i (mod 64)
         brz,pn %o2,2f
-       _ sllx %o4,%g1,%o4       # erster Carry
-        add %g1,32,%g1          # 32-i
+       _ sllx %o4,%g3,%o4       # erster Carry
+        add %g3,32,%g3          # 32-i
 1:        lduw [%o0],%o5        # Digit, zero-extend
           add %o0,4,%o0
-          sllx %o5,%g1,%o5      # shiften
+          sllx %o5,%g3,%o5      # shiften
           or %o4,%o5,%o4        # und mit altem Carry kombinieren
           srlx %o4,32,%o5
           st %o5,[%o1]          # und ablegen
@@ -1239,15 +1239,15 @@
        _ srlx %o4,32,%o0
 #else
 #       srl %o2,0,%o2           # zero-extend %o2 = count
-        sub %g0,%o3,%g1         # 32-i (mod 32)
+        sub %g0,%o3,%g3         # 32-i (mod 32)
         brz,pn %o2,2f
-       _ sll %o4,%g1,%g2        # erster Carry
+       _ sll %o4,%g3,%g2        # erster Carry
 1:        ld [%o0],%o4          # Digit
           add %o0,4,%o0
           srl %o4,%o3,%o5       # shiften
           or %g2,%o5,%o5        # und mit altem Carry kombinieren
           st %o5,[%o1]          # und ablegen
-          sll %o4,%g1,%g2       # neuer Carry
+          sll %o4,%g3,%g2       # neuer Carry
           subcc %o2,1,%o2
           bne,pt %xcc,1b
          _ add %o1,4,%o1
@@ -1290,58 +1290,58 @@
        _ srl %o3,0,%o0
 
 # extern void mulu_loop_down (uintD digit, uintD* sourceptr, uintD* destptr, uintC len);
-C(mulu_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1
+C(mulu_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3
 #       srl %o3,0,%o3           # zero-extend %o3 = len
         mov 0,%o4               # Carry
 1:        sub %o1,4,%o1
-          ld [%o1],%g1          # nächstes Digit
+          ld [%o1],%g3          # nächstes Digit
           sub %o2,4,%o2
-          # mit digit multiplizieren: %o0 * %g1 -> %o5|%g1
-          umul %g1,%o0,%g1
+          # mit digit multiplizieren: %o0 * %g3 -> %o5|%g3
+          umul %g3,%o0,%g3
           rd %y,%o5
-          addcc %o4,%g1,%g1     # und bisherigen Carry addieren
+          addcc %o4,%g3,%g3     # und bisherigen Carry addieren
           addx %g0,%o5,%o4      # High-Digit gibt neuen Carry
           subcc %o3,1,%o3
           bne,pt %xcc,1b
-         _ st %g1,[%o2]         # Low-Digit ablegen
+         _ st %g3,[%o2]         # Low-Digit ablegen
         retl
        _ st %o4,[%o2-4]         # letzten Carry ablegen
 
 # extern uintD muluadd_loop_down (uintD digit, uintD* sourceptr, uintD* destptr, uintC len);
-C(muluadd_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1,%g2, Output in %o0
+C(muluadd_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3,%g2, Output in %o0
 #       srl %o3,0,%o3           # zero-extend %o3 = len
         mov 0,%o4               # Carry
 1:        sub %o1,4,%o1
           ld [%o1],%o5          # nächstes source-Digit
           sub %o2,4,%o2
-          # mit digit multiplizieren: %o0 * %o5 -> %g2|%g1
-          umul %o0,%o5,%g1
+          # mit digit multiplizieren: %o0 * %o5 -> %g2|%g3
+          umul %o0,%o5,%g3
           rd %y,%g2
           ld [%o2],%o5          # nächstes dest-digit
-          addcc %o4,%g1,%g1     # und bisherigen Carry addieren
+          addcc %o4,%g3,%g3     # und bisherigen Carry addieren
           addx %g0,%g2,%o4      # High-Digit gibt neuen Carry
-          addcc %o5,%g1,%g1     # addieren
+          addcc %o5,%g3,%g3     # addieren
           addx %g0,%o4,%o4
           subcc %o3,1,%o3
           bne,pt %xcc,1b
-         _ st %g1,[%o2]         # Low-Digit ablegen
+         _ st %g3,[%o2]         # Low-Digit ablegen
         retl
        _ srl %o4,0,%o0          # letzter Carry
 
 # extern uintD mulusub_loop_down (uintD digit, uintD* sourceptr, uintD* destptr, uintC len);
-C(mulusub_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1,%g2, Output in %o0
+C(mulusub_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3,%g2, Output in %o0
 #       srl %o3,0,%o3           # zero-extend %o3 = len
         mov 0,%o4               # Carry
 1:        sub %o1,4,%o1
           ld [%o1],%o5          # nächstes source-Digit
           sub %o2,4,%o2
-          # mit digit multiplizieren: %o0 * %o5 -> %g2|%g1
-          umul %o0,%o5,%g1
+          # mit digit multiplizieren: %o0 * %o5 -> %g2|%g3
+          umul %o0,%o5,%g3
           rd %y,%g2
           ld [%o2],%o5          # nächstes dest-digit
-          addcc %o4,%g1,%g1     # und bisherigen Carry addieren
+          addcc %o4,%g3,%g3     # und bisherigen Carry addieren
           addx %g0,%g2,%o4      # High-Digit gibt neuen Carry
-          subcc %o5,%g1,%o5     # davon das Low-Digit subtrahieren
+          subcc %o5,%g3,%o5     # davon das Low-Digit subtrahieren
           addx %g0,%o4,%o4
           subcc %o3,1,%o3
           bne,pt %xcc,1b
@@ -1350,7 +1350,7 @@
        _ srl %o4,0,%o0          # letzter Carry
 
 # extern uintD divu_loop_up (uintD digit, uintD* ptr, uintC len);
-C(divu_loop_up:) # Input in %o0,%o1,%o2, verändert %g1, Output in %o0
+C(divu_loop_up:) # Input in %o0,%o1,%o2, verändert %g3, Output in %o0
 #       srl %o2,0,%o2           # zero-extend %o2 = len
         brz,pn %o2,2f
        _ mov 0,%o3              # Rest
@@ -1360,8 +1360,8 @@
           or %o3,%o4,%o3        # zusammen
           udivx %o3,%o0,%o4     # durch digit dividieren
           st %o4,[%o1]          # Quotient ablegen
-          umul %o0,%o4,%g1
-          sub %o3,%g1,%o3       # Rest in den unteren 32 Bit von %o3
+          umul %o0,%o4,%g3
+          sub %o3,%g3,%o3       # Rest in den unteren 32 Bit von %o3
           subcc %o2,1,%o2
           bne,pt %xcc,1b
          _ add %o1,4,%o1
@@ -1369,7 +1369,7 @@
        _ srl %o3,0,%o0          # Rest als Ergebnis
 
 # extern uintD divucopy_loop_up (uintD digit, uintD* sourceptr, uintD* destptr, uintC len);
-C(divucopy_loop_up:) # Input in %o0,%o1,%o2,%o3, verändert %g1, Output in %o0
+C(divucopy_loop_up:) # Input in %o0,%o1,%o2,%o3, verändert %g3, Output in %o0
 #       srl %o3,0,%o3           # zero-extend %o3 = len
         brz,pn %o3,2f
        _ mov 0,%o4              # Rest
@@ -1380,8 +1380,8 @@
           or %o4,%o5,%o4        # zusammen
           udivx %o4,%o0,%o5     # durch digit dividieren
           st %o5,[%o2]          # Quotient ablegen
-          umul %o0,%o5,%g1
-          sub %o4,%g1,%o4       # Rest in den unteren 32 Bit von %o4
+          umul %o0,%o5,%g3
+          sub %o4,%g3,%o4       # Rest in den unteren 32 Bit von %o4
           subcc %o3,1,%o3
           bne,pt %xcc,1b
          _ add %o2,4,%o2