--- src.orig/arisparc.d	Thu Dec  6 00:06:32 2007

+++ src/arisparc.d	Mon Feb  2 15:35:22 2009

@@ -100,11 +100,11 @@

 # 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

 #ifdef sparcv8

         umul    %o0,%o1,%o0

         retl

-       _ rd      %y,%g1

+       _ rd      %y,%g3

 #else

         mov     %o1,%y

         sra     %o0,31,%o3      # Wartetakt, nötig z.B. für SUN SPARCstation IPC

@@ -143,7 +143,7 @@

         mulscc  %o2,%o0,%o2

         mulscc  %o2,%g0,%o2

         and     %o3,%o1,%o3     # %o3 = (0 falls %o0>=0, %o1 falls %o0<0)

-        add     %o2,%o3,%g1     # hi

+        add     %o2,%o3,%g3     # hi

         retl

        _ rd      %y,%o0         # lo

 #endif

@@ -216,7 +216,7 @@

 # 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

 #if defined(sparcv8)

         # Problem: Is udiv worth using (gmp-2.0.2 doesn't use it) ??

         wr      %o0,%g0,%y

@@ -224,9 +224,9 @@

         nop                     # wait 2 | processors such as Ross Hypersparc,

         nop                     # wait 3 | but not for most of the others.

         udiv    %o1,%o2,%o0     # x durch y dividieren, %o0 := q

-        umul    %o0,%o2,%g1     # %g1 := (q*y) mod 2^32

+        umul    %o0,%o2,%g3     # %g3 := (q*y) mod 2^32

         retl

-       _ sub     %o1,%g1,%g1    # %g1 := (xlo-q*y) mod 2^32 = r

+       _ sub     %o1,%g3,%g3    # %g3 := (xlo-q*y) mod 2^32 = r

 #else

         # %o0 = xhi, %o1 = xlo, %o2 = y

 # Divisions-Einzelschritte:

@@ -305,20 +305,20 @@

        _ subcc   %o0,%o2,%o3

         subcc   %o3,%o2,%o0     # muss der Quotient nochmals erhöht werden?

         bcs     Ll03

-       _ mov     %o3,%g1

+       _ mov     %o3,%g3

         # Quotient 2 mal erhöhen, Rest %o0

-        mov     %o0,%g1

+        mov     %o0,%g3

         retl

        _ add     %o1,2,%o0

 Ll02:   # kein Additions-Überlauf.

         # Wegen y>=2^31 muss der Quotient noch höchstens 1 mal erhöht werden:

         bcs     Ll04            # %o0 < %o2 -> Rest %o0 und Quotient %o1 OK

-       _ mov     %o3,%g1

+       _ mov     %o3,%g3

 Ll03:   # Quotient %o1 erhöhen, Rest = %o0-%o2 = %o3

         retl

        _ add     %o1,1,%o0

 Ll04:   # Quotient %o1 und Rest %o0 OK

-        mov     %o0,%g1

+        mov     %o0,%g3

         retl

        _ mov     %o1,%o0

 # Parallelschiene zu La01..La32:

@@ -366,20 +366,20 @@

        _ subcc   %o3,%o2,%o0

         subcc   %o0,%o2,%o3     # muss der Quotient nochmals erhöht werden?

         bcs     Ll06

-       _ mov     %o0,%g1

+       _ mov     %o0,%g3

         # Quotient 2 mal erhöhen, Rest %o3

-        mov     %o3,%g1

+        mov     %o3,%g3

         retl

        _ add     %o1,2,%o0

 Ll05:   # kein Additions-Überlauf.

         # Wegen y>=2^31 muss der Quotient noch höchstens 1 mal erhöht werden:

         bcs     Ll07            # %o3 < %o2 -> Rest %o3 und Quotient %o1 OK

-       _ mov     %o0,%g1

+       _ mov     %o0,%g3

 Ll06:   # Quotient %o1 erhöhen, Rest = %o3-%o2 = %o0

         retl

        _ add     %o1,1,%o0

 Ll07:   # Quotient %o1 und Rest %o3 OK

-        mov     %o3,%g1

+        mov     %o3,%g3

         retl

        _ mov     %o1,%o0

 Lsmalldiv: # Division durch y < 2^31

@@ -416,7 +416,7 @@

 Lc29:   SB0(); SA0(Ld30)        # Bit 2 des Quotienten bestimmen

 Lc30:   SB0(); SA0(Ld31)        # Bit 1 des Quotienten bestimmen

 Lc31:   SB0(); SA0(Ld32)        # Bit 0 des Quotienten bestimmen

-Lc32:   mov     %o0,%g1         # Rest aus %o0 in %g1 abspeichern

+Lc32:   mov     %o0,%g3         # Rest aus %o0 in %g3 abspeichern

         retl

        _ xor     %o1,-1,%o0     # Quotient nach %o0

 # Parallelschiene zu Lc01..Lc32:

@@ -451,7 +451,7 @@

 Ld29:   SB1(); SA1(Lc30)

 Ld30:   SB1(); SA1(Lc31)

 Ld31:   SB1(); SA1(Lc32)

-Ld32:   mov     %o3,%g1         # Rest aus %o3 in %g1 abspeichern

+Ld32:   mov     %o3,%g3         # Rest aus %o3 in %g3 abspeichern

         retl

        _ xor     %o1,-1,%o0     # Quotient nach %o0

 Levendiv: # Division durch gerades y.

@@ -493,7 +493,7 @@

 Le30:   SB0(); SA0(Lf31)        # Bit 1 des Quotienten bestimmen

 Le31:   SB0(); SA0(Lf32)        # Bit 0 des Quotienten bestimmen

 Le32:   SB0()                   # Bit 0 des Restes bestimmen

-        mov     %o0,%g1         # Rest aus %o0 in %g1 abspeichern

+        mov     %o0,%g3         # Rest aus %o0 in %g3 abspeichern

         retl

        _ xor     %o1,-1,%o0     # Quotient nach %o0

 # Parallelschiene zu Le01..Le32:

@@ -529,7 +529,7 @@

 Lf30:   SB1(); SA1(Le31)

 Lf31:   SB1(); SA1(Le32)

 Lf32:   SB1()

-        mov     %o3,%g1         # Rest aus %o0 in %g1 abspeichern

+        mov     %o3,%g3         # Rest aus %o0 in %g3 abspeichern

         retl

        _ xor     %o1,-1,%o0     # Quotient nach %o0

 #endif

@@ -1205,18 +1205,18 @@

 #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

         andcc %o3,%o3,%g0

         be Ll49

-       _ mov %g0,%g1            # Carry := 0

+       _ mov %g0,%g3            # Carry := 0

         sub %o0,4,%o0

 Ll48:     ld [%o0],%o4          # source1-digit

           sub %o1,4,%o1

           ld [%o1],%o5          # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           addxcc %o4,%o5,%o4    # addieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o2,4,%o2

           st %o4,[%o2]          # Digit ablegen

           subcc %o3,1,%o3

@@ -1223,12 +1223,12 @@

           bne Ll48

          _ sub %o0,4,%o0

 Ll49:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if COUNTER_LOOPS

         andcc %o3,%o3,%g0

         be Ll49

-       _ mov %g0,%g1            # Carry := 0

+       _ mov %g0,%g3            # Carry := 0

         sub %o0,4,%o0

         sub %o1,4,%o1

         sll %o3,2,%o3           # %o3 = 4*count

@@ -1237,14 +1237,14 @@

         sub %o2,%o3,%o2         # %o2 = &destptr[-count]

 Ll48:     ld [%o0+%o3],%o4      # source1-digit

           ld [%o1+%o3],%o5      # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           addxcc %o4,%o5,%o4    # addieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           subcc %o3,4,%o3

           bne Ll48

          _ st %o4,[%o2+%o3]     # Digit ablegen

 Ll49:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if UNROLLED_LOOPS

         and %o3,7,%o4           # count mod 8

@@ -1257,7 +1257,7 @@

         sub %o5,%o4,%o5

         jmp %o5                 # Sprung nach _add_loop_down+4*(12+4*8-4*(count mod 8))

        _ subcc %g0,%g0,%g0      # carry löschen

-Ll48:     subcc %g0,%g1,%g0     # carry

+Ll48:     subcc %g0,%g3,%g0     # carry

           ld [%o0+28],%o4       # source1-digit

           ld [%o1+28],%o5       # source2-digit

           addxcc %o5,%o4,%o5    # addieren

@@ -1290,7 +1290,7 @@

           ld [%o1],%o5          # source2-digit

           addxcc %o5,%o4,%o5    # addieren

           st %o5,[%o2]          # Digit ablegen

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o0,32,%o0

           sub %o1,32,%o1

           subcc %o3,8,%o3       # noch mindestens 8 Digits abzuarbeiten?

@@ -1297,7 +1297,7 @@

           bcc Ll48

          _ sub %o2,32,%o2

         retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 # extern uintD addto_loop_down (uintD* sourceptr, uintD* destptr, uintC count);

@@ -1431,18 +1431,18 @@

 #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

         andcc %o3,%o3,%g0

         be Ll56

-       _ mov %g0,%g1            # Carry := 0

+       _ mov %g0,%g3            # Carry := 0

         sub %o0,4,%o0

 Ll55:     ld [%o0],%o4          # source1-digit

           sub %o1,4,%o1

           ld [%o1],%o5          # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           subxcc %o4,%o5,%o4    # subtrahieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o2,4,%o2

           st %o4,[%o2]          # Digit ablegen

           subcc %o3,1,%o3

@@ -1449,12 +1449,12 @@

           bne Ll55

          _ sub %o0,4,%o0

 Ll56:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if COUNTER_LOOPS

         andcc %o3,%o3,%g0

         be Ll56

-       _ mov %g0,%g1            # Carry := 0

+       _ mov %g0,%g3            # Carry := 0

         sub %o0,4,%o0

         sub %o1,4,%o1

         sll %o3,2,%o3           # %o3 = 4*count

@@ -1463,14 +1463,14 @@

         sub %o2,%o3,%o2         # %o2 = &destptr[-count]

 Ll55:     ld [%o0+%o3],%o4      # source1-digit

           ld [%o1+%o3],%o5      # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           subxcc %o4,%o5,%o4    # subtrahieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           subcc %o3,4,%o3

           bne Ll55

          _ st %o4,[%o2+%o3]     # Digit ablegen

 Ll56:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if UNROLLED_LOOPS

         and %o3,7,%o4           # count mod 8

@@ -1483,7 +1483,7 @@

         sub %o5,%o4,%o5

         jmp %o5                 # Sprung nach _sub_loop_down+4*(12+4*8-4*(count mod 8))

        _ subcc %g0,%g0,%g0      # carry löschen

-Ll55:     subcc %g0,%g1,%g0     # carry

+Ll55:     subcc %g0,%g3,%g0     # carry

           ld [%o0+28],%o4       # source1-digit

           ld [%o1+28],%o5       # source2-digit

           subxcc %o4,%o5,%o4    # subtrahieren

@@ -1516,7 +1516,7 @@

           ld [%o1],%o5          # source2-digit

           subxcc %o4,%o5,%o4    # subtrahieren

           st %o4,[%o2]          # Digit ablegen

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o0,32,%o0

           sub %o1,32,%o1

           subcc %o3,8,%o3       # noch mindestens 8 Digits abzuarbeiten?

@@ -1523,22 +1523,22 @@

           bcc Ll55

          _ sub %o2,32,%o2

         retl

-       _ mov %g1,%o0

+       _ mov %g3,%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

         andcc %o3,%o3,%g0

         be Ll58

-       _ mov %o4,%g1            # Carry

+       _ mov %o4,%g3            # Carry

         sub %o0,4,%o0

 Ll57:     ld [%o0],%o4          # source1-digit

           sub %o1,4,%o1

           ld [%o1],%o5          # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           subxcc %o4,%o5,%o4    # subtrahieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o2,4,%o2

           st %o4,[%o2]          # Digit ablegen

           subcc %o3,1,%o3

@@ -1545,12 +1545,12 @@

           bne Ll57

          _ sub %o0,4,%o0

 Ll58:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if COUNTER_LOOPS

         andcc %o3,%o3,%g0

         be Ll58

-       _ mov %o4,%g1            # Carry

+       _ mov %o4,%g3            # Carry

         sub %o0,4,%o0

         sub %o1,4,%o1

         sll %o3,2,%o3           # %o3 = 4*count

@@ -1559,27 +1559,27 @@

         sub %o2,%o3,%o2         # %o2 = &destptr[-count]

 Ll57:     ld [%o0+%o3],%o4      # source1-digit

           ld [%o1+%o3],%o5      # source2-digit

-          subcc %g0,%g1,%g0     # carry

+          subcc %g0,%g3,%g0     # carry

           subxcc %o4,%o5,%o4    # subtrahieren

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           subcc %o3,4,%o3

           bne Ll57

          _ st %o4,[%o2+%o3]     # Digit ablegen

 Ll58:   retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 #if UNROLLED_LOOPS

         and %o3,7,%o5           # count mod 8

-        sll %o5,2,%g1

-        sub %o0,%g1,%o0         # %o0 = &sourceptr1[-(count mod 8)]

-        sub %o1,%g1,%o1         # %o1 = &sourceptr2[-(count mod 8)]

-        sub %o2,%g1,%o2         # %o2 = &destptr[-(count mod 8)]

+        sll %o5,2,%g3

+        sub %o0,%g3,%o0         # %o0 = &sourceptr1[-(count mod 8)]

+        sub %o1,%g3,%o1         # %o1 = &sourceptr2[-(count mod 8)]

+        sub %o2,%g3,%o2         # %o2 = &destptr[-(count mod 8)]

         sll %o5,4,%o5

-        set _subx_loop_down+176,%g1

-        sub %g1,%o5,%g1

-        jmp %g1                 # Sprung nach _subx_loop_down+4*(12+4*8-4*(count mod 8))

+        set _subx_loop_down+176,%g3

+        sub %g3,%o5,%g3

+        jmp %g3                 # Sprung nach _subx_loop_down+4*(12+4*8-4*(count mod 8))

        _ subcc %g0,%o4,%g0      # carry initialisieren

-Ll57:     subcc %g0,%g1,%g0     # carry

+Ll57:     subcc %g0,%g3,%g0     # carry

           ld [%o0+28],%o4       # source1-digit

           ld [%o1+28],%o5       # source2-digit

           subxcc %o4,%o5,%o4    # subtrahieren

@@ -1612,7 +1612,7 @@

           ld [%o1],%o5          # source2-digit

           subxcc %o4,%o5,%o4    # subtrahieren

           st %o4,[%o2]          # Digit ablegen

-          addx %g0,%g0,%g1      # neuer Carry

+          addx %g0,%g0,%g3      # neuer Carry

           sub %o0,32,%o0

           sub %o1,32,%o1

           subcc %o3,8,%o3       # noch mindestens 8 Digits abzuarbeiten?

@@ -1619,7 +1619,7 @@

           bcc Ll57

          _ sub %o2,32,%o2

         retl

-       _ mov %g1,%o0

+       _ mov %g3,%o0

 #endif

 # extern uintD subfrom_loop_down (uintD* sourceptr, uintD* destptr, uintC count);

@@ -1831,10 +1831,10 @@

        _ mov %o3,%o0

 # extern uintD shiftleft_loop_down (uintD* ptr, uintC count, uintC i, uintD carry);

-C(shiftleft_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1, Output in %o0

+C(shiftleft_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3, Output in %o0

         andcc %o1,%o1,%g0

         be Ll72

-       _ sub %g0,%o2,%g1        # 32-i (mod 32)

+       _ sub %g0,%o2,%g3        # 32-i (mod 32)

         sub %o0,4,%o0

 Ll71:     ld [%o0],%o4          # Digit

           subcc %o1,1,%o1

@@ -1841,7 +1841,7 @@

           sll %o4,%o2,%o5       # dessen niedere (32-i) Bits

           or %o3,%o5,%o5        # mit dem alten Carry kombinieren

           st %o5,[%o0]          # Digit ablegen

-          srl %o4,%g1,%o3       # dessen höchste i Bits liefern den neuen Carry

+          srl %o4,%g3,%o3       # dessen höchste i Bits liefern den neuen Carry

           bne Ll71

          _ sub %o0,4,%o0

 Ll72:   retl

@@ -1848,11 +1848,11 @@

        _ mov %o3,%o0

 # extern uintD shiftleftcopy_loop_down (uintD* sourceptr, uintD* destptr, uintC count, uintC i);

-C(shiftleftcopy_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g1,%g2, Output in %o0

+C(shiftleftcopy_loop_down:) # Input in %o0,%o1,%o2,%o3, verändert %g3,%g2, Output in %o0

         andcc %o2,%o2,%g0

         be Ll74

        _ mov 0,%o4              # Carry := 0

-        sub %g0,%o3,%g1         # 32-i (mod 32)

+        sub %g0,%o3,%g3         # 32-i (mod 32)

         sub %o0,4,%o0

 Ll73:     ld [%o0],%o5          # Digit

           subcc %o2,1,%o2

@@ -1860,7 +1860,7 @@

           or %o4,%g2,%g2        # mit dem alten Carry kombinieren

           sub %o1,4,%o1

           st %g2,[%o1]          # Digit ablegen

-          srl %o5,%g1,%o4       # dessen höchste i Bits liefern den neuen Carry

+          srl %o5,%g3,%o4       # dessen höchste i Bits liefern den neuen Carry

           bne Ll73

          _ sub %o0,4,%o0

 Ll74:   retl

@@ -1883,17 +1883,17 @@

        _ mov %o2,%o0

 # 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

         andcc %o1,%o1,%g0

         be Ll78

        _ or %g0,%g0,%o3         # Carry := 0

-        sub %g0,%o2,%g1         # 32-i (mod 32)

+        sub %g0,%o2,%g3         # 32-i (mod 32)

 Ll77:     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 Ll77

          _ add %o0,4,%o0

 Ll78:   retl

@@ -1900,12 +1900,12 @@

        _ mov %o3,%o0

 # 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

         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 Ll80

        _ add %o0,4,%o0

@@ -1914,7 +1914,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 Ll79

          _ add %o0,4,%o0

 Ll80:   retl

@@ -1921,17 +1921,17 @@

        _ mov %o3,%o0

 # 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

-        sub %g0,%o3,%g1         # 32-i (mod 32)

+C(shiftrightcopy_loop_up:) # Input in %o0,%o1,%o2,%o3,%o4, verändert %g3,%g2, Output in %o0

+        sub %g0,%o3,%g3         # 32-i (mod 32)

         andcc %o2,%o2,%g0

         be Ll82

-       _ sll %o4,%g1,%g2        # erster Carry

+       _ sll %o4,%g3,%g2        # erster Carry

 Ll81:     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 Ll81

          _ add %o1,4,%o1

@@ -1982,7 +1982,7 @@

           call _mulu32_         # mit digit multiplizieren

          _ mov %i0,%o0

           addcc %l0,%o0,%o0     # und bisherigen Carry addieren

-          addx %g0,%g1,%l0      # High-Digit gibt neuen Carry

+          addx %g0,%g3,%l0      # High-Digit gibt neuen Carry

           sub %i2,4,%i2

           subcc %i3,1,%i3

           bne Ll86

@@ -1991,16 +1991,16 @@

         ret

        _ restore

 #else

-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

         mov 0,%o4               # Carry

-Ll87:     ld [%o1-4],%g1        # nächstes Digit

-          # mit digit multiplizieren: %o0 * %g1 -> %o5|%g1

+Ll87:     ld [%o1-4],%g3        # nächstes Digit

+          # mit digit multiplizieren: %o0 * %g3 -> %o5|%g3

 #ifdef sparcv8

           sub     %o1,4,%o1

-          umul    %g1,%o0,%g1

+          umul    %g3,%o0,%g3

           rd      %y,%o5

 #else